@cotal-ai/manager 0.101.7 → 0.103.1

package/dist/manager.js

@@ -6,7 +6,7 @@ import { isAbsolute, join, dirname, resolve } from "node:path";
 import Headless from "@xterm/headless";
 import { CotalEndpoint, canonicalJson, MANAGED_HANDOFF_KIND, accountFromCreds, credsClaims, DEFAULT_SERVER, DEV_OWNER, MANAGER_LEASE_RENEW_MS, MANAGER_LEASE_TTL_MS, awaitLeaseExpiry, leaseRemainingMs, STANDING_RENEWABLE_TTL_SEC, assertLifecycleToken, discardLaunchArtifacts, divergentSecretStoreNotice, injectedSecretStoreIdentity, parseDaemonStoreAnswer, parseSecretStoreIdentity, sameSecretStoreIdentity, agentFilePath, clearSpaceHistory, dialerFor, connectorServers, spawnEnvAllow, deprovisionAgent, DeprovisionError, addDeprovisionAccounting, isConcreteChannel, deprovisionTargetPrincipal, firstFreeName, spawnNameError, idFromCreds, identityFromCreds, inspectCredHealth, credsRenewalDelayMs, composeWirePersona, loadAgentFile, listPersonaCatalog, personaCatalogDescription, personaCatalogReadable, loadCotalConfig, modelPolicyRefusal, mintCreds, mintGeneration, mintAcceptedToken, openIssuedStore, acceptedBucket, issuedBucket, mintLifecycleUid, managedRetirementOpId, mkSecretDir, newIdentity, oneLine, actionContext, parsePrincipalKey, principalKey, probeConnect, provisionAgent, provisionAgentDurables, registry, resolveAuthProvider, resolveReadAcl, runAgentBearer, saveAgentFile, subjectMatches, AUTH_ENDPOINT, EP_CMD_RETIRE_LIFECYCLE, controlServiceSubject, eventChannelPrincipal, resolveService, invokeCommand, digestIdToken, } from "@cotal-ai/core";
 import { loadLaunchPersonaFile, PersonaSourceError } from "@cotal-ai/workspace";
-import { agentAuthState, agentCredsDir, agentLifecycleSecretFilePaths, agentSecretFilePaths, agentSecretKeyForFile, authDir, claimIdentityRecord, claimManagerSiblingIdentities, connectorInstallHint, DELIVERY_CREDS_KIND, extensionConnectors, findCotalRoot, getSpaceAuth, hasUserAuthState, loadExtensionsManifest, loadManagerInstanceIdentity, loadMeshes, localTrustOfSpace, manifestExtensionNames, materializeFromManifest, materializeSecretToFile, MEMBERSHIP_RW_CREDS_KIND, mergeLaunchOptions, probeLiveness, remintDaemonCreds, resolveAgentType, resolveOnPath, createManagerInstanceIdentity, spaceKey, spaceMaterialKey, SYSTEM_CREDS_FILES, userAuthStateDir, workspaceSecretStore, writeRenewalRecord } from "@cotal-ai/workspace";
+import { agentAuthState, agentCredsDir, agentLifecycleSecretFilePaths, agentSecretFilePaths, agentSecretKeyForFile, authDir, claimIdentityRecord, claimManagerSiblingIdentities, connectorInstallHint, DEFAULT_SEAT_CAP, DELIVERY_CREDS_KIND, extensionConnectors, findCotalRoot, getSpaceAuth, hasUserAuthState, loadExtensionsManifest, loadManagerInstanceIdentity, loadMeshes, localTrustOfSpace, manifestExtensionNames, materializeFromManifest, materializeSecretToFile, MEMBERSHIP_RW_CREDS_KIND, mergeLaunchOptions, probeLiveness, remintDaemonCreds, resolveAgentType, resolveOnPath, createManagerInstanceIdentity, SEAT_CAP_UNLIMITED, spaceKey, spaceMaterialKey, SYSTEM_CREDS_FILES, userAuthStateDir, workspaceSecretStore, writeRenewalRecord } from "@cotal-ai/workspace";
 import { createRuntime, exitProof, isCustodialRuntime, pollProvedExit, requireRuntimeAdopt, requireRuntimeReap, RuntimeReapUnproven, watchProvedExit, } from "./runtime/index.js";
 import { AttachEndpoint } from "./attach-endpoint.js";
 import { DELIVERY_ADMIN_BOOT_WAIT_MS, isUnansweredDeliveryAdmin, makeManagerEndpointEvictionEvidence, makeManagerEndpointHolderEvictor, untilDeliveryAdminAnswers, withScopedEndpoint } from "./endpoint-evict.js";
@@ -32,7 +32,7 @@ import { ManagerSessionPlane, openSessionLedgerKv } from "./session/index.js";
 // The manager as an ordinary v0.4 `service` endpoint — the §13.1
 // endpoint-serve credential subsystem (gate provisioning, registration barrier, mint fence) plus
 // the register/authorize/serve seams, all driven over a scoped one-shot executor connection.
-import { provisionEndpointGateOpen, endpointRegistrationBarrier, serveIssuanceGateKv, commitSiblingIssuance, markLedgerRowRevoked, epcredRowKey, epgateKey, parseEndpointGate, readEndpointGateGeneration, registerServingInstance, deregisterServiceInstance, serveEndpoint, bindGoal, createGoal, transitionGoal, commitGoalResult, requestGoalCancel, goalAlreadyTerminal, settleGoalUncertain, readGoalResult, readGoalStatus, readGoalSpec, recordGoalIndex, readGoalIndex, clearGoalIndex, listGoalIndex, mintCheckpoint, resumeCheckpoint, readCheckpointSettle, readCheckpointSpec, expireCheckpoint, GOAL_TERMINAL_STATES, goalRefOf, goalProgressTopic, epeSubject, submissionFingerprint, EpEnvelopeError, lifecycleBlocked, lifecycleBlockedFrom, renderLifecycleBlocked, } from "@cotal-ai/core";
+import { provisionEndpointGateOpen, endpointRegistrationBarrier, serveIssuanceGateKv, commitSiblingIssuance, markLedgerRowRevoked, epcredRowKey, epgateKey, parseEndpointGate, readEndpointGateGeneration, registerServingInstance, deregisterServiceInstance, serveEndpoint, bindGoal, createGoal, transitionGoal, commitGoalResult, requestGoalCancel, goalAlreadyTerminal, settleGoalUncertain, readGoalResult, readGoalStatus, readGoalSpec, recordGoalIndex, readGoalIndex, clearGoalIndex, listGoalIndex, mintCheckpoint, resumeCheckpoint, readCheckpointSettle, readCheckpointSpec, expireCheckpoint, GOAL_TERMINAL_STATES, goalRefOf, goalProgressTopic, turnNoticeSubject, epeSubject, submissionFingerprint, EpEnvelopeError, lifecycleBlocked, seatCapRefused, lifecycleBlockedFrom, renderLifecycleBlocked, controlReplyFromThrown, } from "@cotal-ai/core";
 import { MANAGER_ENDPOINT, managerClusterArtifacts, managerCommandDefs, managerContractArtifactValues } from "./manager-service-contract.js";
 import { measureManagerVitals } from "./vitals.js";
 import { staticLifecycleTransport, activateStaticLifecycle, runStaticTerminal, readStaticSlot, casStaticSlot, recordSlotCredential, appendStaticCredentialRow, planStaticSlotResume, ownedBySibling, observeStaticSlot, listStaticSlotObservations, walkStaticSlots, renderStaticSlotObservation, StaticSlotReadError, STATIC_SLOT_READ_FAILED_DETAIL, } from "./static-lifecycle.js";
@@ -136,6 +136,12 @@ const STATIC_RECONCILE_MAX_ATTEMPTS = STATIC_RECONCILE_RETRY_DELAYS_MS.length +
 function retireOpId(lifecycleUid) {
     return managedRetirementOpId(lifecycleUid);
 }
+/** The owner a retained seat resumes under: its inventory identity's, which is the same value the
+ *  adopted seat records as `userOwner`, so a resumed seat is counted against the owner that held
+ *  it before the restart ({@link Manager.ownerSeats}) and not against the mesh's default one. */
+function resumeOwner(entry) {
+    return entry.identity.mode === "user" ? entry.identity.owner : DEV_OWNER;
+}
 /** Sentinel owner-filter value that matches NO agent's `userOwner` (owner tokens never contain a
  *  dash) — what {@link Manager.psOwnerFilter} returns for an unparseable caller so a malformed
  *  principal fail-closes to an empty `ps` instead of an unbounded one. */
@@ -355,6 +361,8 @@ export class Manager {
     eventsRequired;
     /** The operator-set global live-session ceiling (see {@link ManagerOptions.maxSessions}). */
     maxSessions;
+    /** The operator-set per-owner seat ceiling (see {@link ManagerOptions.seatCap}). */
+    seatCap;
     /** The ONE secret store for every kind this manager touches (daemon-cred remint + agent kinds).
      *  See {@link ManagerOptions.secretStore}. */
     secrets;
@@ -371,8 +379,11 @@ export class Manager {
     agents = new Map();
     /** Names whose spawn is in flight (reserved synchronously before the provision await) — counted
      *  toward the ceiling (once per name, see {@link Manager.occupancy}) so two concurrent same-name
-     *  spawns can't both pass the gate (P4a). */
-    reserved = new Set();
+     *  spawns can't both pass the gate (P4a). Each name carries the OWNER its launch was admitted
+     *  for, so the per-owner ceiling ({@link Manager.ownerSeats}) counts a launch from the moment it
+     *  is reserved; a cap read only off `agents` would let a burst of concurrent spawns overshoot it,
+     *  because none of them has a seat yet when the next one checks. */
+    reserved = new Map();
     /** Reserved names whose launch already put its seat in `agents`. The name stays reserved until
      *  the launch settles, so no other spawn can take it, but the ceiling counts that seat through
      *  `agents` and, if it frees young, its cooling stamp, never through the reservation (#906). */
@@ -687,6 +698,7 @@ export class Manager {
         this.onServiceIdentity = opts.onServiceIdentity;
         this.eventsRequired = opts.eventsRequired === true;
         this.maxSessions = opts.maxSessions;
+        this.seatCap = opts.seatCap ?? DEFAULT_SEAT_CAP;
         this.remoteAuthority = opts.remoteAuthority;
         this.remoteExecutorCreds = opts.remoteAuthority?.executorCreds;
         this.remoteSupervisorCreds = opts.remoteAuthority?.supervisorCreds;
@@ -3048,7 +3060,7 @@ export class Manager {
         // only — the action model gives failures a typed channel.
         const unwrap = (r) => {
             if (!r.ok)
-                throw new EpEnvelopeError("failed-precondition", r.error ?? "the operation failed");
+                throw new EpEnvelopeError((r.code ?? "failed-precondition"), r.error ?? "the operation failed", r.details);
             return r.data;
         };
         // The admin-family serve gate: every `manager.admin`-class
@@ -5531,6 +5543,16 @@ export class Manager {
         // collision, a manifest name and a `--name` override all meet it, and before the reservation.
         if (name.startsWith(CHAT_ALIAS_PREFIX))
             return { ok: false, error: `the name "${name}" starts with "${CHAT_ALIAS_PREFIX}", which is reserved for chat sessions; pick another name` };
+        // THE PER-OWNER CEILING, read in the same synchronous window as the reserve below rather than
+        // beside the host capacity gate higher up: the count it takes must be the one the reservation
+        // lands against, or a burst of concurrent launches for one owner each reads a count taken
+        // before any of the others reserved, and they all pass. Nothing between here and the reserve
+        // awaits. It refuses BEFORE `onEffect`, so the launch states `not-executed` and leaves no
+        // name, no mint and no footprint behind.
+        const owner = this.launchOwner(opts, spawner);
+        const overCap = this.seatCapRefusal(owner);
+        if (overCap)
+            return { ok: false, code: overCap.code, error: overCap.message, ...(overCap.details ? { details: overCap.details } : {}) };
         // Set once the agent's footprint (durables + creds, or the user-mode grant + secret files)
         // exists; cleared when a live slot takes ownership. If it survives to `finally`, the spawn threw
         // AFTER provisioning (buildLaunch / runtime.spawn) — the orphan-rollback tears it down. Carries
@@ -5547,7 +5569,7 @@ export class Manager {
         // Taken right before the try so its finally is the only release; a refusal belongs above the
         // allocation, where there is no name to give back.
         hooks?.onEffect?.();
-        this.reserved.add(name);
+        this.reserved.set(name, owner);
         try {
             // A stable nkey identity assigned at spawn: the public key is the agent's card.id (threaded via
             // COTAL_ID); the seed is retained to mint matching creds later.
@@ -5577,8 +5599,8 @@ export class Manager {
             // freshly-minted nkey; user mode keys on the derived owner (opts.owner, else a u_-owner spawner)
             // + the alias — derived HERE where the mode and owner source are in scope.
             const agentTriple = this.userMode
-                ? { owner: opts.owner ?? (spawner && parsePrincipalKey(spawner)?.owner.startsWith("u_") ? parsePrincipalKey(spawner).owner : DEV_OWNER), actor: name, uid: lifecycleUid }
-                : { owner: DEV_OWNER, actor: identity.id, uid: lifecycleUid };
+                ? { owner, actor: name, uid: lifecycleUid }
+                : { owner, actor: identity.id, uid: lifecycleUid };
             // THE EVENT GRANT, derived from the principal that was actually ALLOCATED and never from the
             // display name. A display name is UI convenience: this mesh permits two live agents to carry
             // one, so a name-keyed channel fuses two principals onto one subject and, in auth mode,
@@ -5661,7 +5683,7 @@ export class Manager {
                 if ("error" in prep) {
                     if (prep.refused !== undefined)
                         hooks?.onUndone?.(prep.refused);
-                    return { ok: false, error: prep.error, ...(prep.details ? { details: prep.details } : {}) };
+                    return { ok: false, error: prep.error, ...(prep.refused !== undefined ? { code: prep.refused } : {}), ...(prep.details ? { details: prep.details } : {}) };
                 }
                 // THE HOST'S UID WINS (#1972). On the local arm this is the value passed in, unchanged. On
                 // the hosted enrollment arm the host selected it, and from here every lifecycle-keyed thing
@@ -6000,15 +6022,15 @@ export class Manager {
         catch (e) {
             // Failure after reserve (provision / launch threw): the slot was never live, so no cold-start
             // was paid — the reserved rollback (finally) is enough, no cooling stamp.
-            // A lifecycle-blocked envelope already named the barrier; keep its details on the ControlReply
-            // so follow/CLI/cotal_spawn do not collapse it to a generic string (#873). An extension can throw
+            // Keep the envelope's code and lifecycle details on the ControlReply so the serve boundary
+            // can carry the refusal's classification and barrier to the caller. An extension can throw
             // any value, and an envelope's `message` is only typed as a string, so the refusal text always
             // comes from rejectionText; telling an envelope apart is guarded because a thrown Proxy can
             // throw from `instanceof` or from its own fields.
             const error = rejectionText(e);
             try {
                 if (e instanceof EpEnvelopeError)
-                    return { ok: false, error: renderLifecycleBlocked(error, e), ...(e.details ? { details: e.details } : {}) };
+                    return controlReplyFromThrown(e, error);
             }
             catch { /* not a readable envelope */ }
             return { ok: false, error };
@@ -6108,7 +6130,7 @@ export class Manager {
                     return { ok: false, agents: [], error: `retained agent "${entry.name}" is already managed or reserved` };
             }
             for (const entry of entries) {
-                this.reserved.add(entry.name);
+                this.reserved.set(entry.name, resumeOwner(entry));
                 batchReservations.push(entry.name);
             }
             const preflight = [];
@@ -6528,7 +6550,7 @@ export class Manager {
     }
     async launchPreparedResume(entry, prepared, batchReserved, supervised) {
         if (!batchReserved)
-            this.reserved.add(entry.name);
+            this.reserved.set(entry.name, resumeOwner(entry));
         try {
             // Unit B F5(b): recover the STATIC identity's nkey seed from the adopted credential (the
             // creds file embeds it) so the manager stays this incarnation's RENEWAL OWNER across a
@@ -6932,7 +6954,7 @@ export class Manager {
         const cooling = this.coolingCount();
         let reserved = 0;
         let launching = 0;
-        for (const name of this.reserved) {
+        for (const name of this.reserved.keys()) {
             const placed = this.reservedLive.has(name);
             if (!placed)
                 reserved++;
@@ -6963,6 +6985,59 @@ export class Manager {
                 : "waiting frees no slot; despawn one";
         return `at capacity (${this.occupancyText(o)}); ${remedy}`;
     }
+    /**
+     * The owner a launch belongs to, read ONCE so the per-owner ceiling, the agent's addressing
+     * triple and the user-mode provisioner cannot charge three different owners for one seat. A
+     * static or open mesh has one owner by construction; a user-auth mesh takes the spec's owner,
+     * else the owner of the principal that asked, which is what {@link provisionUserAgent} resolves
+     * from the same two values (it refuses outright where this falls back, so the two never disagree
+     * on an admitted launch).
+     */
+    launchOwner(opts, spawner) {
+        if (!this.userMode)
+            return DEV_OWNER;
+        const asked = spawner === undefined ? undefined : parsePrincipalKey(spawner)?.owner;
+        return opts.owner ?? (asked?.startsWith("u_") ? asked : DEV_OWNER);
+    }
+    /** The owner of a seat this manager supervises, by the same rule {@link launchOwner} admitted it
+     *  under: a user-mode seat records its derived owner, and every other seat is the mesh's one owner. */
+    seatOwner(a) {
+        return a.userOwner ?? DEV_OWNER;
+    }
+    /**
+     * Live seats this manager holds for one owner: the seats it supervises, plus the launches it has
+     * reserved for that owner and not yet placed. It deliberately does NOT count cooling stamps — a
+     * cooling slot is a seat that already freed, and the recycle floor it holds is a global
+     * fork-bomb bound (P4c), not one tenant's occupancy. Mirrors {@link occupancy}'s reserved rule,
+     * so a reservation stops being counted twice the moment its seat reaches `agents`.
+     */
+    ownerSeats(owner) {
+        let seats = 0;
+        for (const a of this.agents.values())
+            if (this.seatOwner(a) === owner)
+                seats++;
+        for (const [name, reservedFor] of this.reserved)
+            if (reservedFor === owner && !this.reservedLive.has(name))
+                seats++;
+        return seats;
+    }
+    /**
+     * The per-owner ceiling, consulted at accept: `undefined` admits the launch, and a refusal
+     * carries the owner's count and the cap so a caller can render a remedy and a script can decide
+     * without re-reading prose. Distinct from {@link capacityRefusal}, which bounds the HOST: that
+     * one frees when anyone stops a seat or a cooling slot expires, this one frees only when THIS
+     * owner stops one of its own, or the operator raises the cap, so they cannot share a sentence.
+     */
+    seatCapRefusal(owner) {
+        const cap = this.seatCap;
+        if (cap === SEAT_CAP_UNLIMITED)
+            return undefined;
+        const seats = this.ownerSeats(owner);
+        if (seats < cap)
+            return undefined;
+        return seatCapRefused(`owner ${owner} holds ${seats} of the ${cap} seat${cap === 1 ? "" : "s"} manager ${this.managerInstanceId} admits per owner; ` +
+            `stop one of that owner's seats, or ask the operator who runs this manager for a higher seat cap`, { owner, seats, cap });
+    }
     async opStop(args, caller, admin) {
         const name = String(args.name ?? "").trim();
         const a = this.agents.get(name);
@@ -8120,6 +8195,11 @@ export class Manager {
         }
         finally {
             this.goalReconcileDone = true;
+            // A seat that pulled during the window was refused, and a predecessor may have died before
+            // its notice went out, so every seat holding a rebuilt turn is told once.
+            const seats = new Map([...this.pendingTurns.values()].map((p) => [`${p.seat.owner}.${p.seat.actor}.${p.seat.uid}`, p.seat]));
+            for (const seat of seats.values())
+                this.noticeSeatTurns(seat);
         }
     }
     /** Settle ONE inherited goal by evidence: no goal record (a crash between the index write and the
@@ -8429,8 +8509,7 @@ export class Manager {
             // outcome unknown.
             if (acceptance === undefined) {
                 const details = reply.details;
-                // A hard-pinned name a live incarnation holds is the one refusal here that names its own code.
-                const code = undone ?? (reply.code === "already-exists" ? "already-exists" : "failed-precondition");
+                const code = undone ?? reply.code ?? "failed-precondition";
                 rejectAccept(new EpEnvelopeError(code, reply.error ?? "spawn refused at accept", details, effectStarted && undone === undefined ? undefined : "not-executed"));
                 return;
             }
@@ -8644,6 +8723,7 @@ export class Manager {
         };
         this.pendingTurns.set(key, pending);
         this.ensureTurnSweep();
+        this.noticeSeatTurns(pending.seat);
         const acceptance = { name: a.name, owner: t.owner, actor: t.actor, uid: t.lifecycleUid, goalId, fingerprint, deadlineAt, executor };
         this.turnAcceptances.set(key, { acceptance, ref });
         this.emitGoalProgress(ref, executor.epoch, { phase: "relayed" });
@@ -8666,13 +8746,33 @@ export class Manager {
         // its own pause, so handing it to the seat buys work whose yield is refused. It also cannot be
         // allowed to stay the head, or one expired turn dams every later turn for that seat.
         const now = Date.now();
-        const turns = [...this.pendingTurns.values()]
+        const head = [...this.pendingTurns.values()]
             .filter((p) => p.seat.owner === c.owner && p.seat.actor === c.actor && p.seat.uid === c.uid)
             .filter((p) => now < p.deadlineAt)
             .sort((x, y) => x.acceptedAt - y.acceptedAt)
-            .slice(0, 1)
-            .map((p) => ({ goalId: p.goalId, payload: p.payload, acceptedAt: p.acceptedAt, deadlineAt: p.deadlineAt }));
-        return { turns };
+            .slice(0, 1);
+        for (const p of head)
+            p.pulledAt ??= now;
+        const turns = head.map((p) => ({ goalId: p.goalId, payload: p.payload, acceptedAt: p.acceptedAt, deadlineAt: p.deadlineAt }));
+        return { turns, notices: true };
+    }
+    /** Tell a seat that its `turn-pending` answer changed (SPEC 14.3 turn notice), over the serve
+     *  connection that holds this instance's reply rows. The notice carries no turn and the seat
+     *  pulls on it, so a lost notice delays that seat until its next pull, and nothing else. */
+    noticeSeatTurns(seat) {
+        const serve = this.serviceServe;
+        if (!serve)
+            return;
+        // An issued seat credential reads only the versioned rail, under the generation it was issued.
+        const a = this.agents.get(seat.name);
+        const generation = a?.lifecycleUid === seat.uid ? a.issued?.generation : undefined;
+        const caller = { owner: seat.owner, actor: seat.actor, uid: seat.uid, ...(generation !== undefined ? { generation } : {}) };
+        try {
+            serve.nc.publish(turnNoticeSubject(this.space, this.managerInstanceId, serve.grant.epoch, caller), new TextEncoder().encode(JSON.stringify({ v: 1 })));
+        }
+        catch (e) {
+            console.error(`! turn notice for ${seat.actor} failed: ${rejectionText(e)}`);
+        }
     }
     /** A seat names a turn by goal id alone when it yields, so one incarnation holding two callers'
      *  turns under one id could not say which of the two it answered. */
@@ -8767,6 +8867,7 @@ export class Manager {
         this.emitGoalProgress(p.ref, epoch, { phase: "terminal", state: fact.state, ...(fact.data !== undefined ? { data: fact.data } : {}) });
         await clearGoalIndex(gw.ctx, p.ref);
         this.pendingTurns.delete(key);
+        this.noticeSeatTurns(p.seat);
         this.markTurnLatchDropped(key, at);
         this.rememberSettledTurn(key, fact.state, at);
         this.maybeStopTurnSweep();
@@ -8820,6 +8921,7 @@ export class Manager {
             throw e;
         }
         this.emitGoalProgress(ref, epoch, { phase: "terminal", state: fact.state, ...(fact.data !== undefined ? { data: fact.data } : {}) });
+        this.noticeSeatTurns(p.seat);
         this.markTurnLatchDropped(key);
         this.rememberSettledTurn(key, fact.state, Date.now());
         await clearGoalIndex(gw.ctx, ref);
@@ -8837,6 +8939,7 @@ export class Manager {
         const key = goalKey(p.ref);
         if (!this.pendingTurns.delete(key))
             return;
+        this.noticeSeatTurns(p.seat);
         this.markTurnLatchDropped(key);
         const epoch = this.serviceServe?.grant.epoch ?? 0;
         try {
@@ -8943,6 +9046,20 @@ export class Manager {
         // The prune above is the one event after which the sweep may have nothing left to do, and
         // the settle-time callers cannot see it: they run when an answer has just been remembered.
         this.maybeStopTurnSweep();
+        // A notice is at-most-once, so a seat offline when it went out has not pulled its head turn.
+        // Repeat the notice until it does; a seat that pulled is not told again for that turn.
+        const heads = new Map();
+        for (const p of this.pendingTurns.values()) {
+            if (now >= p.deadlineAt)
+                continue;
+            const k = `${p.seat.owner}.${p.seat.actor}.${p.seat.uid}`;
+            const h = heads.get(k);
+            if (h === undefined || p.acceptedAt < h.acceptedAt)
+                heads.set(k, p);
+        }
+        for (const p of heads.values())
+            if (p.pulledAt === undefined)
+                this.noticeSeatTurns(p.seat);
         for (const p of [...this.pendingTurns.values()]) {
             if (now < p.deadlineAt)
                 continue;