@aragon-agent/cli 0.6.20 → 0.6.22

package/dist/team/runtime.d.ts

@@ -113,15 +113,30 @@ export declare class TeamRuntime {
      */
     private readonly pendingBackoffs;
     /**
-     * The dispatch supervisor, LIVE for the current dispatch only (team-overseer).
-     * Null when the provider is absent/disabled/off, and reset to null at every
-     * dispatch end so nothing supervision-shaped leaks across dispatches.
+     * The dispatch supervisor, LIVE for the current dispatch only
+     * (team-overseer / subagent-overseer-v2). Null when the provider is not
+     * wired or the policy is off, and reset to null at every dispatch end so
+     * nothing supervision-shaped leaks across dispatches.
+     *
+     * THE GATE IS "PROVIDER PRESENT AND POLICY ON" (R-P0-2), deliberately NOT
+     * the provider's live `active()`: a dispatch that STARTS without a fast
+     * tier must still get a MonitorLoop, because the promise this feature
+     * makes is "timeout is never a death sentence" - an unavailable tier
+     * degrades the tick to an announced unassisted wait rather than falling
+     * back to the legacy hard abort. `active()` is re-read every tick.
      */
     private overseer;
-    /** The soft timers, same lifetime as `overseer`. */
+    /** The per-child silence windows, same lifetime as `overseer`. */
     private supervision;
+    /** The cadence ladder (subagent-overseer-v2 D-2), same lifetime. */
+    private monitor;
     /** Applied interventions for the in-flight dispatch's outcome. */
     private interventions;
+    /** Labels already told the supervisor went quiet on them (D-5, once). */
+    private readonly quietNotified;
+    /** Edge-latched "a tick ran unassisted" (D-10), per dispatch. */
+    private overseerDegraded;
+    private overseerDegradedTicks;
     constructor(deps: TeamRuntimeDeps);
     subscribe(listener: TeamEventListener): () => void;
     /**
@@ -175,17 +190,44 @@ export declare class TeamRuntime {
      */
     private isBlocked;
     /**
-     * One trigger handled: look, then apply. Fired from a supervision timer and
-     * therefore async-and-forgotten; nothing here may throw.
+     * One SILENCE trigger handled: look, then apply. Fired from a supervision
+     * timer and therefore async-and-forgotten; nothing here may throw.
      *
-     * QUIET (`decision === null` — provider gone, budget spent) CLEARS the
-     * child's timers: supervision that has nothing left to say should stop
-     * waking up, and the child's own hard ceilings take over.
+     * A NULL DECISION HAS THREE DISTINCT QUIETS: the look budget is spent ->
+     * say so ONCE and stop supervising this child (D-5); an inspection of this
+     * child is already in flight -> re-arm and let it settle (R-P1-4); the
+     * tier is gone -> clear quietly, because the cadence tick - not the
+     * silence path - owns the degraded announcements (D-4).
      */
     private inspectAndApply;
     private applyDecision;
     /** Record one applied decision on the outcome, the run and the event stream. */
     private recordIntervention;
+    /** R-P1-5: a label ticks only once STARTED and not yet settled. */
+    private isMonitorLive;
+    /**
+     * One ASSISTED cadence tick: build the batch over the due labels, apply
+     * every returned decision through the same `applyDecision` the silence
+     * path uses (D-3's single application path), and hand the map back so the
+     * loop can move the ladders. Labels the batch skipped (single-flight,
+     * R-P1-4) are absent from the map.
+     */
+    private monitorInspectBatch;
+    /**
+     * One DEGRADED cadence tick (D-4 / D-10): the fast tier is missing right
+     * now. The children wait unassisted - announced per child through the same
+     * event shape, never killed - and the fact is edge-latched here, NOT in
+     * the interventions ledger.
+     */
+    private noteDegradedTick;
+    /** The supervisor goes quiet on one child, ONCE (D-5 / D-10). */
+    private noteQuiet;
+    /**
+     * The dispatch-wide fool-proof total is spent (R-P1-6): stop the whole
+     * loop and emit ONE aggregate notice under a pseudo-label that is never a
+     * child slug.
+     */
+    private noteDispatchExhausted;
     /**
      * The final phase of an attempt, in a FIXED ORDER: aborted, then timed out,
      * then error, then no-summary, then done.