@cydm/happy-elves 0.1.0-beta.495 → 0.1.0-beta.496

package/apps/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-cli",
-  "version": "0.1.0-beta.495",
+  "version": "0.1.0-beta.496",
   "private": true,
   "type": "module"
 }

package/apps/daemon/dist/direct/server.js

@@ -742,6 +742,7 @@ class DirectState {
             acpxVersion: runtimeCapabilities.version,
             daemonVersion: daemonPackage.version,
             ...(runtimeCapabilities.turnPrimitives ? { turnPrimitives: runtimeCapabilities.turnPrimitives } : {}),
+            runtimeEvents: { forwardCursor: true },
             sessionPrimitives: runtimePrimitiveSupportForCapabilities(runtimeCapabilities.sessionPrimitives, "native"),
             ...(runtimeCapabilities.sidechat ? { sidechat: runtimeCapabilities.sidechat } : {}),
             directoryBrowser: true,

package/apps/daemon/dist/orchestration/watcher.d.ts

@@ -22,6 +22,7 @@ export declare function catchUpSubscriptionEvents(input: {
     config: DaemonConfig;
     subscription: OrchestrationSubscriptionRecord;
 }): Promise<SubscriptionCatchUpResult>;
+export declare function remoteEventCursorForSubscription(crewMachineId: string, subscription: Pick<OrchestrationSubscriptionRecord, "remoteEventCursor" | "remoteEventSeq">): string | undefined;
 export declare function attentionFromReconcile(result: TurnReconcileResult): {
     eventType: TaskAttentionEventType;
     reason: string;

package/apps/daemon/dist/orchestration/watcher.js

@@ -4,10 +4,13 @@ import { RemoteCommandError, requestRemoteMachineResult } from "../relay/remote-
 import { runtimeRead } from "../session/runtime-truth.js";
 import { activeSubscriptionsForTurn, appendAttention, markSubscriptionLiveness, markSubscriptionRemoteScan, recordTurnRuntimeBinding, } from "./store.js";
 import { scheduleRemoteOrchestrationWork } from "./remote-work-budget.js";
+import { relayMachineRegistry } from "../state.js";
 const remoteCatchupsInFlight = new Map();
 const legacyRemoteCursorFallbackUntil = new Map();
+const remoteForwardCursorConfirmed = new Set();
 const legacyRemoteCursorFallbackMs = 5 * 60 * 1000;
 const initialRemoteEventCursor = "event_000000000000";
+const forwardEventCursorSinceBeta = 495;
 export async function observeSessionEvent(input) {
     const attention = attentionFromEvent(input.payload);
     if (!attention) {
@@ -116,11 +119,10 @@ export async function catchUpSubscriptionEvents(input) {
 }
 async function catchUpSubscriptionEventsInternal(input) {
     const crewMachineId = input.subscription.crewMachineId ?? input.config.machineId;
-    const remoteCursorEnabled = crewMachineId !== input.config.machineId && canUseRemoteEventCursor(crewMachineId);
-    const remoteCursor = remoteCursorEnabled
-        ? input.subscription.remoteEventCursor
-            ?? (input.subscription.remoteEventSeq ? `event_${String(input.subscription.remoteEventSeq).padStart(12, "0")}` : initialRemoteEventCursor)
+    const remoteCursor = crewMachineId !== input.config.machineId
+        ? remoteEventCursorForSubscription(crewMachineId, input.subscription)
         : undefined;
+    const remoteCursorEnabled = remoteCursor !== undefined;
     try {
         const result = crewMachineId === input.config.machineId
             ? await runtimeRead(input.config, {
@@ -171,7 +173,14 @@ async function catchUpSubscriptionEventsInternal(input) {
         // the forward cursor in its response. Treat that as the legacy path for
         // this machine; in particular, never advance a durable cursor from a
         // page whose peer cannot prove append-only progress.
-        if (crewMachineId !== input.config.machineId && remoteCursorEnabled && !result.cursorSupported && !result.nextAfter) {
+        if (crewMachineId !== input.config.machineId && result.cursorSupported === true) {
+            remoteForwardCursorConfirmed.add(crewMachineId);
+        }
+        else if (crewMachineId !== input.config.machineId && remoteCursorEnabled && !result.nextAfter) {
+            // A peer that accepted the forward request but cannot prove the cursor
+            // contract is no longer trusted. Remove the positive handshake so the
+            // next safe, legacy-compatible request can renegotiate it.
+            remoteForwardCursorConfirmed.delete(crewMachineId);
             legacyRemoteCursorFallbackUntil.set(crewMachineId, Date.now() + legacyRemoteCursorFallbackMs);
         }
         const observed = await observeSubscriptionRuntimeEvents({
@@ -201,6 +210,7 @@ async function catchUpSubscriptionEventsInternal(input) {
     }
     catch (error) {
         if (crewMachineId !== input.config.machineId && remoteCursorEnabled && isRemoteEventCursorCompatibilityFailure(error)) {
+            remoteForwardCursorConfirmed.delete(crewMachineId);
             legacyRemoteCursorFallbackUntil.set(crewMachineId, Date.now() + legacyRemoteCursorFallbackMs);
         }
         await appendOrchestrationAudit(input.config, "orchestration.subscription.catchup_failed", `Subscription catch-up failed for ${input.subscription.taskId}`, {
@@ -216,13 +226,63 @@ async function catchUpSubscriptionEventsInternal(input) {
 function canUseRemoteEventCursor(crewMachineId) {
     const until = legacyRemoteCursorFallbackUntil.get(crewMachineId);
     if (until === undefined)
-        return true;
+        return remotePeerAdvertisesForwardCursor(crewMachineId);
     if (until <= Date.now()) {
         legacyRemoteCursorFallbackUntil.delete(crewMachineId);
-        return true;
+        return remotePeerAdvertisesForwardCursor(crewMachineId);
     }
     return false;
 }
+export function remoteEventCursorForSubscription(crewMachineId, subscription) {
+    const fallbackUntil = legacyRemoteCursorFallbackUntil.get(crewMachineId);
+    if (fallbackUntil !== undefined && fallbackUntil > Date.now())
+        return undefined;
+    if (fallbackUntil !== undefined)
+        legacyRemoteCursorFallbackUntil.delete(crewMachineId);
+    const advertised = remotePeerForwardCursorSupport(crewMachineId);
+    // An explicit old version wins over a stale persisted cursor (for example,
+    // after a peer downgrade). Unknown manifests are different: a persisted
+    // cursor is still positive evidence until the peer identity is refreshed.
+    if (advertised === false)
+        return undefined;
+    // A persisted cursor is positive evidence from a previous successful
+    // forward-page response. It remains usable even when the peer's manifest is
+    // temporarily unavailable during reconnect.
+    if (subscription.remoteEventCursor)
+        return subscription.remoteEventCursor;
+    if (advertised !== true || !canUseRemoteEventCursor(crewMachineId))
+        return undefined;
+    return subscription.remoteEventSeq
+        ? `event_${String(subscription.remoteEventSeq).padStart(12, "0")}`
+        : initialRemoteEventCursor;
+}
+function remotePeerAdvertisesForwardCursor(crewMachineId) {
+    return remotePeerForwardCursorSupport(crewMachineId) === true;
+}
+function remotePeerForwardCursorSupport(crewMachineId) {
+    const machine = relayMachineRegistry.get(crewMachineId);
+    const daemonVersion = machine?.capabilities.daemonVersion?.trim();
+    const advertisedFeature = machine?.capabilities.runtimeEvents?.forwardCursor;
+    if (advertisedFeature === false)
+        return false;
+    if (!daemonVersion) {
+        if (advertisedFeature === true || remoteForwardCursorConfirmed.has(crewMachineId))
+            return true;
+        return undefined;
+    }
+    // Published beta495 introduced the append-only eventsPage `after` field.
+    // Workspace daemons also publish an explicit feature bit. The historical
+    // package version 0.1.0 alone is not evidence: older development daemons
+    // used that same version while rejecting `after`.
+    const match = /^0\.1\.0-beta\.(\d+)$/.exec(daemonVersion);
+    if (match && Number(match[1]) < forwardEventCursorSinceBeta)
+        return false;
+    if (advertisedFeature === true || remoteForwardCursorConfirmed.has(crewMachineId))
+        return true;
+    if (match)
+        return Number(match[1]) >= forwardEventCursorSinceBeta;
+    return undefined;
+}
 function isRemoteEventCursorCompatibilityFailure(error) {
     if (!(error instanceof RemoteCommandError))
         return false;

package/apps/daemon/dist/relay/register.js

@@ -49,6 +49,7 @@ export async function registerMachine(ws, config) {
             acpxVersion: capabilities.version,
             daemonVersion: daemonPackage.version,
             ...(capabilities.turnPrimitives ? { turnPrimitives: capabilities.turnPrimitives } : {}),
+            runtimeEvents: { forwardCursor: true },
             sessionPrimitives: runtimePrimitiveSupportForCapabilities(capabilities.sessionPrimitives, "native"),
             ...(capabilities.sidechat ? { sidechat: capabilities.sidechat } : {}),
             directoryBrowser: true,

package/apps/daemon/dist/session/he-official/common.d.ts

@@ -45,6 +45,9 @@ export declare function machineList(config: DaemonConfig): {
                 turnPrimitives?: {
                     steer: "native" | "unsupported";
                 };
+                runtimeEvents?: {
+                    forwardCursor: boolean;
+                };
                 sidechat?: import("../../../../../packages/shared/dist/index.js").SidechatCapability;
                 directoryBrowser?: boolean;
                 filePreview?: boolean;

package/apps/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-daemon",
-  "version": "0.1.0-beta.495",
+  "version": "0.1.0-beta.496",
   "private": true,
   "type": "module"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.495",
+  "version": "0.1.0-beta.496",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {

package/packages/shared/dist/protocol-schemas.d.ts

@@ -136,6 +136,9 @@ export declare const capabilitiesSchema: z.ZodObject<{
             unsupported: "unsupported";
         }>;
     }, z.core.$strip>>;
+    runtimeEvents: z.ZodOptional<z.ZodObject<{
+        forwardCursor: z.ZodBoolean;
+    }, z.core.$strip>>;
     sidechat: z.ZodOptional<z.ZodObject<{
         strategy: z.ZodEnum<{
             native: "native";
@@ -289,6 +292,9 @@ export declare const machineSnapshotSchema: z.ZodObject<{
                 unsupported: "unsupported";
             }>;
         }, z.core.$strip>>;
+        runtimeEvents: z.ZodOptional<z.ZodObject<{
+            forwardCursor: z.ZodBoolean;
+        }, z.core.$strip>>;
         sidechat: z.ZodOptional<z.ZodObject<{
             strategy: z.ZodEnum<{
                 native: "native";

package/packages/shared/dist/protocol-schemas.js

@@ -72,6 +72,9 @@ export const capabilitiesSchema = z.object({
     daemonVersion: z.string().optional(),
     sessionPrimitives: sessionPrimitivesSchema.optional(),
     turnPrimitives: turnPrimitivesSchema.optional(),
+    runtimeEvents: z.object({
+        forwardCursor: z.boolean(),
+    }).optional(),
     sidechat: sidechatCapabilitySchema.optional(),
     directoryBrowser: z.boolean().optional(),
     filePreview: z.boolean().optional(),

package/packages/shared/dist/protocol-types.d.ts

@@ -66,6 +66,9 @@ export type MachineSnapshot = {
         turnPrimitives?: {
             steer: "native" | "unsupported";
         };
+        runtimeEvents?: {
+            forwardCursor: boolean;
+        };
         sidechat?: SidechatCapability;
         directoryBrowser?: boolean;
         filePreview?: boolean;