@beeos-ai/device-agent 0.15.0 → 0.16.0

package/dist/plugins/agent-sync/index.js

@@ -4,19 +4,36 @@
  * Each attached device owns an independent logical runtime lease even when
  * multiple device runtimes share one OS process. Lease credentials remain
  * memory-only and are never included in logs.
+ *
+ * Registration, heartbeat and lease fencing are owned by the harness SDK's
+ * `RuntimeRegistrationCoordinator`; this plugin keeps only the durable
+ * registration lineage and the Types4 agent projection it publishes.
  */
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { heartbeatRuntime, registerRuntime, syncAgents, } from "../../adapters/agent-gateway-client.js";
+import { AgentGatewayClient, InstanceAuthorityRuntimeRegistrationTransport, RuntimeRegistrationCoordinator, RuntimeRegistrationJournalAdvanceRequiredError, RuntimeRegistrationOwnerResetRequiredError, signAgentMessage, } from "@beeos-ai/cloud-harness-sdk";
+import { syncAgents, } from "../../adapters/agent-gateway-client.js";
 import { AGENT_PROJECTION_HASH_DOMAIN, DEVICE_RUNTIME_CAPABILITIES, DEVICE_RUNTIME_CONTRACT_REVISION, DEVICE_RUNTIME_METHODS, DEVICE_RUNTIME_RPC_PROTOCOL_VERSION, verifiedAdmittedManifestDigest, } from "../../runtime-authority/contract.js";
 import { runtimeDomainHash, sha256Hex, } from "../../runtime-authority/canonical.js";
+import { DEVICE_NATIVE_MANIFEST_DIGEST, DEVICE_NATIVE_RUNTIME_MANIFEST } from "../../runtime-authority/device-prompt.gen.js";
 const REGISTER_RETRY_MS = 5_000;
 const HANDOFF_RETRY_MS = 65_000;
 const SYNC_RETRY_MS = 5_000;
 const REGISTRATION_INTENT_HASH_DOMAIN = "beeos.device-agent.registration-intent.v1";
-export function resolveRegistrationManifestDigest() {
-    return verifiedAdmittedManifestDigest();
+/**
+ * A `fenced` registration is recoverable once the predecessor's control-plane
+ * lease settles. Keep the pre-SDK 65 s handoff wait instead of the SDK's
+ * shorter default so we do not thrash the authority while that lease is live.
+ */
+const HANDOFF_BACKOFF = Object.freeze({
+    maxAttempts: Number.POSITIVE_INFINITY,
+    initialDelayMs: HANDOFF_RETRY_MS,
+    maxDelayMs: HANDOFF_RETRY_MS,
+    factor: 1,
+});
+export function resolveRegistrationManifestDigest(cloudTarget = false) {
+    return cloudTarget ? DEVICE_NATIVE_MANIFEST_DIGEST : verifiedAdmittedManifestDigest();
 }
 /**
  * Cluster treats registrationId as an idempotency key for one immutable
@@ -29,37 +46,52 @@ export function buildRuntimeRegistrationId(identityFingerprint, manifestDigest,
     return `device-agent-${identityFingerprint.slice(0, 16)}-${generationHash.slice(0, 24)}`;
 }
 function registrationIntentHash(manifestDigest) {
+    const native = manifestDigest === DEVICE_NATIVE_MANIFEST_DIGEST;
     return runtimeDomainHash(REGISTRATION_INTENT_HASH_DOMAIN, {
         contractRevision: DEVICE_RUNTIME_CONTRACT_REVISION,
         manifestDigest,
         runtimeRpcProtocolVersion: DEVICE_RUNTIME_RPC_PROTOCOL_VERSION,
-        runtimeMethods: DEVICE_RUNTIME_METHODS,
-        capabilities: DEVICE_RUNTIME_CAPABILITIES,
+        runtimeMethods: native ? DEVICE_NATIVE_RUNTIME_MANIFEST.runtimeMethods : DEVICE_RUNTIME_METHODS,
+        capabilities: native ? DEVICE_NATIVE_RUNTIME_MANIFEST.capabilities : DEVICE_RUNTIME_CAPABILITIES,
     });
 }
-export function parseExpectedJournalGeneration(error) {
-    const match = `${error.message}\n${error.body ?? ""}`.match(/expected=([1-9][0-9]*)/);
-    return match?.[1] ?? null;
+/** Adapt the bridge-client keypair into the harness SDK request identity. */
+function requestIdentity(identity) {
+    return {
+        publicKey: identity.publicKey,
+        sign: (message) => signAgentMessage(message, identity.privateKey),
+    };
 }
 export class AgentSyncPlugin {
     opts;
     name = "agent-sync";
     ctx;
     stopped = true;
-    generation = 0;
-    controlTimer = null;
-    expiryTimer = null;
-    syncTimer = null;
     periodicSync = null;
-    lease = null;
+    restartTimer = null;
+    syncTimer = null;
+    coordinator = null;
     identity = null;
     registration = null;
     acceptedRevision = 0;
     acceptedHash = "";
+    syncedEpoch = null;
+    initializing = false;
     queue = Promise.resolve();
+    authorityListeners = new Set();
     constructor(opts) {
         this.opts = opts;
     }
+    currentLease() {
+        const lease = this.coordinator?.authorityLease;
+        if (!lease || !this.registration)
+            return null;
+        return { ...lease, journalStoreId: this.registration.journalStoreId, journalGeneration: this.registration.journalGeneration };
+    }
+    subscribeAuthority(listener) {
+        this.authorityListeners.add(listener);
+        return () => this.authorityListeners.delete(listener);
+    }
     init(ctx) {
         this.ctx = ctx;
     }
@@ -67,27 +99,34 @@ export class AgentSyncPlugin {
         if (!this.ctx || this.ctx.config.standalone)
             return;
         this.stopped = false;
-        const generation = ++this.generation;
-        await this.enqueue(() => this.registerOnce(generation));
+        await this.enqueue(() => this.startRegistration());
+        await this.drain();
         const interval = this.opts.intervalMs ??
-            Number(process.env.BEEOS_AGENT_SYNC_INTERVAL_MS ?? "0");
+            Number(process.env.BEEOS_AGENT_SYNC_INTERVAL_MS ?? "30000");
         if (interval > 0) {
             this.periodicSync = setInterval(() => {
-                void this.enqueue(() => this.syncProjection(generation, false));
+                void this.enqueue(() => this.syncProjection(false));
             }, interval);
             this.periodicSync.unref?.();
         }
     }
     async stop() {
         this.stopped = true;
-        this.generation++;
         this.clearTimers();
-        this.lease = null;
+        this.coordinator?.stop();
+        this.coordinator = null;
+        for (const listener of this.authorityListeners)
+            listener();
         this.identity = null;
+        this.syncedEpoch = null;
         await this.queue.catch(() => undefined);
     }
-    async registerOnce(generation) {
-        if (!this.isCurrent(generation) || !this.ctx)
+    /**
+     * Build the harness registration coordinator for the current durable
+     * lineage and let it own registration, heartbeat and lease fencing.
+     */
+    async startRegistration() {
+        if (!this.isCurrent() || !this.ctx)
             return;
         const { config, log } = this.ctx;
         if (!config.agentGatewayUrl)
@@ -95,13 +134,13 @@ export class AgentSyncPlugin {
         const identity = await this.opts.loadIdentity().catch(() => null);
         if (!identity) {
             log.warn("runtime-authority: identity unavailable; retrying registration");
-            this.scheduleRegister(REGISTER_RETRY_MS, generation);
+            this.scheduleRestart(REGISTER_RETRY_MS);
             return;
         }
         this.identity = identity;
         let manifestDigest;
         try {
-            manifestDigest = resolveRegistrationManifestDigest();
+            manifestDigest = resolveRegistrationManifestDigest(Boolean(config.cloudTargetInstanceId));
         }
         catch (error) {
             // A defective contract cannot heal by retrying, and the gateway rejects it
@@ -111,138 +150,123 @@ export class AgentSyncPlugin {
         }
         const fingerprint = sha256Hex(identity.publicKey);
         const registration = await this.ensureRegistrationState(fingerprint, manifestDigest);
-        const payload = {
+        const gateway = new AgentGatewayClient({
+            baseUrl: config.agentGatewayUrl,
+            identity: requestIdentity(identity),
+        });
+        const transport = new InstanceAuthorityRuntimeRegistrationTransport({
+            gateway,
+            registrationId: registration.registrationId,
+        });
+        const coordinator = new RuntimeRegistrationCoordinator(transport, {
             registrationId: registration.registrationId,
             handlerIdentity: `device-agent:${fingerprint.slice(0, 32)}`,
             contractRevision: DEVICE_RUNTIME_CONTRACT_REVISION,
-            manifestDigest,
-            runtimeRpcProtocolVersion: DEVICE_RUNTIME_RPC_PROTOCOL_VERSION,
-            runtimeMethods: [...DEVICE_RUNTIME_METHODS],
-            capabilities: [...DEVICE_RUNTIME_CAPABILITIES],
+            runtimeMethods: (config.cloudTargetInstanceId ? DEVICE_NATIVE_RUNTIME_MANIFEST.runtimeMethods : DEVICE_RUNTIME_METHODS),
+            capabilities: (config.cloudTargetInstanceId ? DEVICE_NATIVE_RUNTIME_MANIFEST.capabilities : DEVICE_RUNTIME_CAPABILITIES),
+            manifestDigest: manifestDigest,
             journalStoreId: registration.journalStoreId,
             journalGeneration: registration.journalGeneration,
-        };
+            instanceIdentityKeyId: `device:${fingerprint}`,
+            targetInstanceId: config.cloudTargetInstanceId,
+            signIdentityProof: (message) => signAgentMessage(message, identity.privateKey),
+            fencedRetry: HANDOFF_BACKOFF,
+        }, (reason, cause) => this.onLeaseLost(reason, cause), () => this.now());
+        const previous = this.coordinator;
+        this.coordinator = coordinator;
+        previous?.stop();
+        coordinator.subscribeAuthority((lease) => this.onAuthorityChanged(lease));
+        this.initializing = true;
+        let lease;
         try {
-            const result = await registerRuntime({
-                agentGatewayUrl: config.agentGatewayUrl,
-                identity,
-                payload,
-                fetchImpl: this.opts.fetchImpl,
-                now: this.opts.now,
-                randomUUID: this.opts.randomUUID,
-            });
-            if (!this.isCurrent(generation))
-                return;
-            if (result.status !== "active" ||
-                !result.instanceId ||
-                !result.leaseId ||
-                !result.runtimeLeaseCredential ||
-                !result.leaseExpiresAt ||
-                !result.heartbeatIntervalMs ||
-                !result.runtimeEpoch) {
-                log.warn({ status: result.status, activeRuntimeEpoch: result.activeRuntimeEpoch }, "runtime-authority: registration fenced; waiting for handoff");
-                this.dropLease();
-                this.scheduleRegister(HANDOFF_RETRY_MS, generation);
-                return;
-            }
-            if (Date.parse(result.leaseExpiresAt) <= this.now()) {
-                throw new Error("runtime authority returned an expired lease");
-            }
-            const sameEpoch = this.lease?.runtimeEpoch === result.runtimeEpoch;
-            this.lease = {
-                instanceId: result.instanceId,
-                leaseId: result.leaseId,
-                runtimeEpoch: result.runtimeEpoch,
-                runtimeLeaseCredential: result.runtimeLeaseCredential,
-                leaseExpiresAt: result.leaseExpiresAt,
-                heartbeatIntervalMs: result.heartbeatIntervalMs,
-            };
-            if (!sameEpoch) {
-                this.acceptedRevision = 0;
-                this.acceptedHash = "";
-            }
-            this.scheduleExpiry(generation);
-            log.info({
-                runtimeEpoch: this.lease.runtimeEpoch,
-                leaseExpiresAt: this.lease.leaseExpiresAt,
-            }, "runtime-authority: active lease acquired");
-            await this.syncProjection(generation, true);
-            this.scheduleHeartbeat(this.lease.heartbeatIntervalMs, generation);
+            lease = await coordinator.start();
         }
-        catch (error) {
-            if (!this.isCurrent(generation))
-                return;
-            const gatewayError = error;
-            const expectedGeneration = parseExpectedJournalGeneration(gatewayError);
-            const rolled = expectedGeneration
-                ? await this.rollRegistrationState(fingerprint, manifestDigest, expectedGeneration)
-                : false;
-            const retryMs = rolled
-                ? 0
-                : gatewayError.status === 409
-                    ? HANDOFF_RETRY_MS
-                    : REGISTER_RETRY_MS;
-            log.warn({
-                err: gatewayError.message,
-                status: gatewayError.status,
-                retryMs,
-                ...(rolled ? { journalGeneration: expectedGeneration } : {}),
-            }, "runtime-authority: registration failed");
-            this.dropLease();
-            this.scheduleRegister(retryMs, generation);
+        finally {
+            this.initializing = false;
+        }
+        if (!this.isCurrent()) {
+            coordinator.stop();
+            return;
+        }
+        if (lease) {
+            // The listener is muted while the coordinator starts; publish the first
+            // projection here so callers can rely on start() having registered.
+            this.syncedEpoch = lease.runtimeEpoch;
+            log.info({ runtimeEpoch: lease.runtimeEpoch, leaseExpiresAt: lease.leaseExpiresAt }, "runtime-authority: active lease acquired");
+            await this.syncProjection(true);
         }
     }
-    async heartbeat(generation) {
-        if (!this.isCurrent(generation) || !this.ctx || !this.identity || !this.lease)
+    /** Only a new runtime epoch needs a fresh projection; renewals do not. */
+    onAuthorityChanged(lease) {
+        for (const listener of this.authorityListeners)
+            listener();
+        if (!lease) {
+            this.syncedEpoch = null;
+            this.acceptedRevision = 0;
+            this.acceptedHash = "";
             return;
-        const active = this.lease;
-        try {
-            const result = await heartbeatRuntime({
-                agentGatewayUrl: this.ctx.config.agentGatewayUrl,
-                identity: this.identity,
-                registrationId: this.registrationId(),
-                payload: {
-                    leaseId: active.leaseId,
-                    handlerIdentity: this.handlerIdentity(this.identity),
-                    runtimeEpoch: active.runtimeEpoch,
-                },
-                fetchImpl: this.opts.fetchImpl,
-                now: this.opts.now,
-                randomUUID: this.opts.randomUUID,
-            });
-            if (!this.isCurrent(generation) || this.lease !== active)
-                return;
-            if (result.status !== "renewed" ||
-                !result.runtimeLeaseCredential ||
-                !result.leaseExpiresAt) {
-                this.ctx.log.warn({ status: result.status, activeRuntimeEpoch: result.activeRuntimeEpoch }, "runtime-authority: heartbeat fenced");
-                this.dropLease();
-                this.scheduleRegister(REGISTER_RETRY_MS, generation);
-                return;
-            }
-            this.lease = {
-                ...active,
-                runtimeLeaseCredential: result.runtimeLeaseCredential,
-                leaseExpiresAt: result.leaseExpiresAt,
-            };
-            this.scheduleExpiry(generation);
-            this.scheduleHeartbeat(active.heartbeatIntervalMs, generation);
         }
-        catch (error) {
-            if (!this.isCurrent(generation) || this.lease !== active)
-                return;
-            this.ctx.log.warn({ err: error.message }, "runtime-authority: heartbeat transport failure");
-            if (Date.parse(active.leaseExpiresAt) > this.now()) {
-                this.scheduleHeartbeat(Math.min(active.heartbeatIntervalMs, REGISTER_RETRY_MS), generation);
-            }
-            else {
-                this.dropLease();
-                this.scheduleRegister(REGISTER_RETRY_MS, generation);
-            }
+        if (this.initializing)
+            return;
+        if (lease.runtimeEpoch === this.syncedEpoch)
+            return;
+        this.syncedEpoch = lease.runtimeEpoch;
+        this.acceptedRevision = 0;
+        this.acceptedHash = "";
+        void this.enqueue(() => this.syncProjection(true));
+    }
+    onLeaseLost(reason, cause) {
+        this.syncedEpoch = null;
+        this.acceptedRevision = 0;
+        this.acceptedHash = "";
+        const log = this.ctx?.log;
+        if (cause instanceof RuntimeRegistrationJournalAdvanceRequiredError) {
+            log?.warn({ expectedJournalGeneration: cause.expectedJournalGeneration }, "runtime-authority: journal generation must advance");
+            void this.enqueue(() => this.rollAndRestart(cause.expectedJournalGeneration));
+            return;
+        }
+        if (cause instanceof RuntimeRegistrationOwnerResetRequiredError) {
+            log?.error("runtime-authority: journal store owner reset required; registration is fenced until an operator resets the journal identity");
+            return;
+        }
+        if (reason === "expired") {
+            log?.warn("runtime-authority: lease expired; advancing journal generation");
+            void this.enqueue(() => this.rollAndRestart());
+            return;
+        }
+        // Fenced and transient failures are already retried by the coordinator.
+        log?.warn({ reason, err: cause?.message }, "runtime-authority: lease lost; coordinator will retry registration");
+    }
+    /**
+     * The authority fenced the old journal lineage. Roll the durable generation
+     * exactly once, then rebuild the coordinator so it re-registers the new id.
+     */
+    async rollAndRestart(expectedGeneration) {
+        if (!this.isCurrent() || !this.ctx || !this.identity || !this.registration) {
+            return;
         }
+        const manifestDigest = resolveRegistrationManifestDigest();
+        const fingerprint = sha256Hex(this.identity.publicKey);
+        const current = this.registration;
+        const target = expectedGeneration ?? (BigInt(current.journalGeneration) + 1n).toString();
+        if (BigInt(target) <= BigInt(current.journalGeneration)) {
+            // Already at the requested generation; wait out the predecessor lease.
+            this.scheduleRestart(HANDOFF_RETRY_MS);
+            return;
+        }
+        await this.publishRegistrationState({
+            ...current,
+            registrationId: buildRuntimeRegistrationId(fingerprint, manifestDigest, target, this.nextUUID()),
+            journalGeneration: target,
+        });
+        this.scheduleRestart(0);
     }
-    async syncProjection(generation, force, allowConflictRetry = true) {
-        if (!this.isCurrent(generation) || !this.ctx || !this.identity || !this.lease)
+    async syncProjection(force, allowConflictRetry = true) {
+        if (!this.isCurrent() || !this.ctx || !this.identity || !this.coordinator) {
+            return;
+        }
+        const lease = this.coordinator.lease;
+        if (!lease)
             return;
         const declarations = await this.opts.buildDeclarations().catch((error) => {
             this.ctx.log.warn({ err: error.message }, "agent-sync: declaration build failed");
@@ -258,37 +282,35 @@ export class AgentSyncPlugin {
         if (!force && canonicalHash === this.acceptedHash)
             return;
         const revision = this.acceptedRevision + 1;
-        const active = this.lease;
-        const snapshotId = `device-${active.runtimeEpoch}-${revision}-${canonicalHash.slice(0, 16)}`;
+        const snapshotId = `device-${lease.runtimeEpoch}-${revision}-${canonicalHash.slice(0, 16)}`;
         try {
             const result = await syncAgents({
                 agentGatewayUrl: this.ctx.config.agentGatewayUrl,
                 identity: this.identity,
                 request: {
-                    runtimeEpoch: active.runtimeEpoch,
+                    runtimeEpoch: lease.runtimeEpoch,
                     revision: String(revision),
                     snapshotId,
                     canonicalHash,
                     agentsComplete: true,
                     skillsComplete: true,
                     agents,
-                    runtimeLeaseCredential: active.runtimeLeaseCredential,
+                    runtimeLeaseCredential: lease.runtimeLeaseCredential,
                 },
                 fetchImpl: this.opts.fetchImpl,
                 now: this.opts.now,
                 randomUUID: this.opts.randomUUID,
             });
-            if (!this.isCurrent(generation) || this.lease !== active)
+            if (!this.isCurrent())
                 return;
             if (!result.accepted) {
                 const acceptedRevision = Number(result.revision);
-                if (result.runtimeEpoch !== active.runtimeEpoch) {
+                if (result.runtimeEpoch !== lease.runtimeEpoch) {
                     this.ctx.log.warn({
-                        runtimeEpoch: active.runtimeEpoch,
+                        runtimeEpoch: lease.runtimeEpoch,
                         acceptedRuntimeEpoch: result.runtimeEpoch,
                     }, "agent-sync: projection fenced by a newer runtime epoch");
-                    this.dropLease();
-                    this.scheduleRegister(REGISTER_RETRY_MS, generation);
+                    this.restartRegistration();
                     return;
                 }
                 if (Number.isSafeInteger(acceptedRevision) && acceptedRevision > 0) {
@@ -297,10 +319,10 @@ export class AgentSyncPlugin {
                 }
                 if (result.canonicalHash !== canonicalHash) {
                     if (allowConflictRetry) {
-                        await this.syncProjection(generation, true, false);
+                        await this.syncProjection(true, false);
                     }
                     else {
-                        this.scheduleSyncRetry(generation);
+                        this.scheduleSyncRetry();
                     }
                 }
                 return;
@@ -311,21 +333,28 @@ export class AgentSyncPlugin {
                 created: result.created,
                 updated: result.updated,
                 deactivated: result.deactivated,
-                runtimeEpoch: active.runtimeEpoch,
+                runtimeEpoch: lease.runtimeEpoch,
                 revision: this.acceptedRevision,
             }, "agent-sync: runtime projection accepted");
         }
         catch (error) {
-            if (!this.isCurrent(generation))
+            if (!this.isCurrent())
                 return;
             const gatewayError = error;
             this.ctx.log.warn({ err: gatewayError.message, status: gatewayError.status }, "agent-sync: projection failed");
+            if (gatewayError.status === 409 && allowConflictRetry) {
+                // A restart can reuse a live lease whose earlier process published a
+                // different hash at revision 1. Advance the projection, not the lease.
+                this.acceptedRevision = Math.max(this.acceptedRevision, Math.trunc(this.now()));
+                await this.syncProjection(true, false);
+                return;
+            }
             if (gatewayError.status === 401 || gatewayError.status === 409) {
-                this.dropLease();
-                this.scheduleRegister(REGISTER_RETRY_MS, generation);
+                // The lease credential was rejected; re-register rather than retrying it.
+                this.restartRegistration();
                 return;
             }
-            this.scheduleSyncRetry(generation);
+            this.scheduleSyncRetry();
         }
     }
     toProjection(declarations, identity) {
@@ -339,6 +368,8 @@ export class AgentSyncPlugin {
             ...(agent.version ? { version: agent.version } : {}),
             ...(agent.avatarUrl ? { avatarUrl: agent.avatarUrl } : {}),
             ...(agent.homepage ? { homepage: agent.homepage } : {}),
+            ...(this.ctx?.config.vlm?.model?.trim()
+                ? { defaultModel: this.ctx.config.vlm.model.trim() } : {}),
             capabilities: {
                 canvas: agent.capabilities?.canvas === true,
                 terminal: agent.capabilities?.terminal === true,
@@ -363,62 +394,36 @@ export class AgentSyncPlugin {
         }))
             .sort((left, right) => left.runtimeAgentUid.localeCompare(right.runtimeAgentUid));
     }
-    scheduleRegister(delayMs, generation) {
-        if (!this.isCurrent(generation))
+    restartRegistration() {
+        if (!this.isCurrent())
             return;
-        if (this.controlTimer)
-            clearTimeout(this.controlTimer);
-        this.controlTimer = setTimeout(() => {
-            this.controlTimer = null;
-            void this.enqueue(() => this.registerOnce(generation));
-        }, delayMs);
+        this.coordinator?.stop();
+        this.coordinator = null;
+        this.syncedEpoch = null;
+        this.acceptedRevision = 0;
+        this.acceptedHash = "";
+        this.scheduleRestart(REGISTER_RETRY_MS);
     }
-    scheduleHeartbeat(delayMs, generation) {
-        if (!this.isCurrent(generation))
+    scheduleRestart(delayMs) {
+        if (!this.isCurrent())
             return;
-        if (this.controlTimer)
-            clearTimeout(this.controlTimer);
-        this.controlTimer = setTimeout(() => {
-            this.controlTimer = null;
-            void this.enqueue(() => this.heartbeat(generation));
+        if (this.restartTimer)
+            clearTimeout(this.restartTimer);
+        this.restartTimer = setTimeout(() => {
+            this.restartTimer = null;
+            void this.enqueue(() => this.startRegistration());
         }, delayMs);
-        this.controlTimer.unref?.();
+        this.restartTimer.unref?.();
     }
-    scheduleSyncRetry(generation) {
-        if (!this.isCurrent(generation) || this.syncTimer)
+    scheduleSyncRetry() {
+        if (!this.isCurrent() || this.syncTimer)
             return;
         this.syncTimer = setTimeout(() => {
             this.syncTimer = null;
-            void this.enqueue(() => this.syncProjection(generation, true));
+            void this.enqueue(() => this.syncProjection(true));
         }, SYNC_RETRY_MS);
         this.syncTimer.unref?.();
     }
-    scheduleExpiry(generation) {
-        if (this.expiryTimer)
-            clearTimeout(this.expiryTimer);
-        const expected = this.lease;
-        if (!expected)
-            return;
-        const remaining = Math.max(0, Date.parse(expected.leaseExpiresAt) - this.now());
-        this.expiryTimer = setTimeout(() => {
-            this.expiryTimer = null;
-            if (!this.isCurrent(generation) || this.lease !== expected)
-                return;
-            this.ctx?.log.warn("runtime-authority: lease expired");
-            this.dropLease();
-            this.scheduleRegister(REGISTER_RETRY_MS, generation);
-        }, remaining);
-        this.expiryTimer.unref?.();
-    }
-    registrationId() {
-        if (!this.registration) {
-            throw new Error("runtime registration state is unavailable");
-        }
-        return this.registration.registrationId;
-    }
-    handlerIdentity(identity) {
-        return `device-agent:${sha256Hex(identity.publicKey).slice(0, 32)}`;
-    }
     async ensureRegistrationState(fingerprint, manifestDigest) {
         if (this.registration)
             return this.registration;
@@ -441,18 +446,6 @@ export class AgentSyncPlugin {
             journalGeneration,
         });
     }
-    async rollRegistrationState(fingerprint, manifestDigest, expectedGeneration) {
-        const current = await this.ensureRegistrationState(fingerprint, manifestDigest);
-        if (BigInt(expectedGeneration) <= BigInt(current.journalGeneration)) {
-            return false;
-        }
-        await this.publishRegistrationState({
-            ...current,
-            registrationId: buildRuntimeRegistrationId(fingerprint, manifestDigest, expectedGeneration, this.nextUUID()),
-            journalGeneration: expectedGeneration,
-        });
-        return true;
-    }
     async readRegistrationState(identityFingerprint) {
         const file = this.registrationStateFile(identityFingerprint);
         if (!file)
@@ -496,37 +489,35 @@ export class AgentSyncPlugin {
     nextUUID() {
         return this.opts.randomUUID ? this.opts.randomUUID() : randomUUID();
     }
-    dropLease() {
-        this.lease = null;
-        if (this.expiryTimer)
-            clearTimeout(this.expiryTimer);
-        this.expiryTimer = null;
-    }
     clearTimers() {
-        for (const timer of [
-            this.controlTimer,
-            this.expiryTimer,
-            this.syncTimer,
-            this.periodicSync,
-        ]) {
+        for (const timer of [this.periodicSync, this.restartTimer, this.syncTimer]) {
             if (timer)
                 clearTimeout(timer);
         }
-        this.controlTimer = null;
-        this.expiryTimer = null;
-        this.syncTimer = null;
         this.periodicSync = null;
+        this.restartTimer = null;
+        this.syncTimer = null;
     }
     now() {
         return this.opts.now ? this.opts.now() : Date.now();
     }
-    isCurrent(generation) {
-        return !this.stopped && generation === this.generation;
+    isCurrent() {
+        return !this.stopped;
     }
     enqueue(work) {
         const next = this.queue.then(work, work);
         this.queue = next.catch(() => undefined);
         return next;
     }
+    /** Wait until no further work is chained onto the serial queue. */
+    async drain() {
+        let current = this.queue;
+        while (true) {
+            await current;
+            if (this.queue === current)
+                return;
+            current = this.queue;
+        }
+    }
 }
 //# sourceMappingURL=index.js.map