@cydm/happy-elves 0.1.0-beta.502 → 0.1.0-beta.504

package/README.md

@@ -6,8 +6,8 @@ Public beta CLI for Happy Elves.
 
 Run once in the existing user account; it detects %USERPROFILE%\.happy-elves\hosted, keeps the current daemon and sessions running, installs the independent updater, and registers per-user startup.
 
-    npm.cmd install --prefix $HOME\.happy-elves\management-entry --ignore-scripts --no-audit --no-fund --package-lock=false @cydm/happy-elves@0.1.0-beta.502
-    npm.cmd exec --yes --package @cydm/happy-elves@0.1.0-beta.502 -- happy-elves-updater install --state-root $HOME\.happy-elves\hosted --autostart
+    npm.cmd install --prefix $HOME\.happy-elves\management-entry --ignore-scripts --no-audit --no-fund --package-lock=false @cydm/happy-elves@0.1.0-beta.504
+    npm.cmd exec --yes --package @cydm/happy-elves@0.1.0-beta.504 -- happy-elves-updater install --state-root $HOME\.happy-elves\hosted --autostart
 
 The same updater entrypoint works on macOS after selecting a permanent user prefix.
 

package/apps/cli/package.json

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

package/apps/daemon/dist/runtime/headless-event-projector.js

@@ -363,13 +363,18 @@ export function historicalEventsFromRuntimeEvents(runtimeEvents) {
         authoritativeTextItems: completedTextItemIds,
     });
     const events = [];
-    const userPromptKeys = new Set();
+    const userPromptItemIds = new Set();
     const addEvent = (event) => {
         if (event.payload.type === "user_prompt") {
-            const key = `${event.turnId}\0${event.payload.text}`;
-            if (userPromptKeys.has(key))
-                return;
-            userPromptKeys.add(key);
+            // The same provider item can arrive through both the canonical item
+            // list and the append-only event log. Deduplicate only by that stable
+            // item identity; text (including trailing newlines) is not identity.
+            const itemId = event.itemId ?? event.payload.itemId;
+            if (itemId) {
+                if (userPromptItemIds.has(itemId))
+                    return;
+                userPromptItemIds.add(itemId);
+            }
         }
         events.push(event);
     };
@@ -849,7 +854,7 @@ function historicalEventFromItem(item) {
 }
 export function historicalEventsFromThread(items, turns, limit, runtimeEvents = []) {
     const events = [];
-    const userPromptKeys = new Set();
+    const userPromptItemIds = new Set();
     // Canonical ThreadItems are authoritative for text and for any tool item
     // the provider materialized.  Some HE providers intentionally keep
     // orchestration calls only in the event log, though (for example a
@@ -861,10 +866,15 @@ export function historicalEventsFromThread(items, turns, limit, runtimeEvents =
     const canonicalToolCallIds = new Set();
     const addEvent = (event) => {
         if (event.payload.type === "user_prompt") {
-            const key = `${event.turnId}\0${event.payload.text}`;
-            if (userPromptKeys.has(key))
-                return;
-            userPromptKeys.add(key);
+            // Canonical items and runtime events may describe the same item. Do
+            // not collapse distinct user messages by text: providers are allowed
+            // to emit two prompts with equal text in one turn.
+            const itemId = event.itemId ?? event.payload.itemId;
+            if (itemId) {
+                if (userPromptItemIds.has(itemId))
+                    return;
+                userPromptItemIds.add(itemId);
+            }
         }
         events.push(event);
     };

package/apps/daemon/dist/session/native-history-refresh.d.ts

@@ -1,4 +1,12 @@
 import type { DaemonConfig, SessionState } from "../types.js";
+export type NativeHistoryRefreshOptions = {
+    /**
+     * Recovery workers may wait for the provider operation itself. User-facing
+     * reads keep the short bounded race, but a background worker needs the
+     * completion edge so it can publish the repaired retained transcript.
+     */
+    waitForCompletion?: boolean;
+};
 /**
  * Mark a managed provider session's history dirty after a new Headless turn.
  *
@@ -22,4 +30,4 @@ export declare function invalidateNativeHistoryRefreshForLoadedSession(session:
  * truth reads; otherwise an old same-turn duplicate remains visible until an
  * internal caller manually invokes the runtime operation.
  */
-export declare function refreshNativeHistoryForLoadedSession(session: SessionState, config: DaemonConfig | undefined, requestId: string): Promise<SessionState>;
+export declare function refreshNativeHistoryForLoadedSession(session: SessionState, config: DaemonConfig | undefined, requestId: string, options?: NativeHistoryRefreshOptions): Promise<SessionState>;

package/apps/daemon/dist/session/native-history-refresh.js

@@ -9,6 +9,10 @@ const orchestrationRefreshRetryAt = new Map();
 const orchestrationRefreshGenerations = new Map();
 const orchestrationRefreshRetryDelayMs = 1_000;
 const orchestrationRefreshMaxWaitMs = 2_000;
+function cleanupOrchestrationRefresh(refreshKey, entry) {
+    if (orchestrationRefreshes.get(refreshKey) === entry)
+        orchestrationRefreshes.delete(refreshKey);
+}
 /**
  * Mark a managed provider session's history dirty after a new Headless turn.
  *
@@ -48,7 +52,7 @@ export function invalidateNativeHistoryRefreshForLoadedSession(session) {
  * truth reads; otherwise an old same-turn duplicate remains visible until an
  * internal caller manually invokes the runtime operation.
  */
-export async function refreshNativeHistoryForLoadedSession(session, config, requestId) {
+export async function refreshNativeHistoryForLoadedSession(session, config, requestId, options = {}) {
     const isNative = session.source === "native";
     const isManagedProviderSession = session.source !== "native" && Boolean(session.providerSessionId);
     if (!isNative && !isManagedProviderSession)
@@ -66,19 +70,20 @@ export async function refreshNativeHistoryForLoadedSession(session, config, requ
         }
         const active = orchestrationRefreshes.get(refreshKey);
         if (active) {
+            if (options.waitForCompletion)
+                return await active.promise;
             const remainingMs = Math.max(0, orchestrationRefreshMaxWaitMs - (Date.now() - active.startedAt));
             const outcome = await Promise.race([
                 active.promise.then((result) => ({ kind: "result", result })),
                 new Promise((resolve) => setTimeout(() => resolve({ kind: "timeout" }), remainingMs)),
             ]);
             if (outcome.kind === "timeout") {
-                active.abandoned = true;
-                if (orchestrationRefreshes.get(refreshKey) === active)
-                    orchestrationRefreshes.delete(refreshKey);
-                orchestrationRefreshGenerations.set(refreshKey, (orchestrationRefreshGenerations.get(refreshKey) ?? 0) + 1);
-                // Disposing the client cancels the bounded IPC request instead of
-                // leaving every later official read behind the same hung promise.
-                void getHeadlessRuntimeManager(session.cwd).invalidateClientForBinding(session.runtimeBinding, session.cwd);
+                // Keep the provider read alive after the short foreground deadline.
+                // Native history reads can legitimately take several seconds on a
+                // remote/Windows provider.  The caller remains bounded, while the
+                // singleflight operation continues and publishes the repaired
+                // projection when it completes.  Explicit generation invalidation
+                // (for example, a newer terminal turn) is the only cancellation path.
                 return sessions.get(session.sessionId) ?? session;
             }
             const result = outcome.result;
@@ -88,7 +93,7 @@ export async function refreshNativeHistoryForLoadedSession(session, config, requ
             if (!active.abandoned && active.generation !== (orchestrationRefreshGenerations.get(refreshKey) ?? 0)) {
                 if (orchestrationRefreshes.get(refreshKey) === active)
                     orchestrationRefreshes.delete(refreshKey);
-                return await refreshNativeHistoryForLoadedSession(session, config, requestId);
+                return await refreshNativeHistoryForLoadedSession(session, config, requestId, options);
             }
             if (active.abandoned)
                 return sessions.get(session.sessionId) ?? session;
@@ -97,34 +102,38 @@ export async function refreshNativeHistoryForLoadedSession(session, config, requ
         const operation = refreshNativeHistory(session, config, requestId, false, refreshKey, generation);
         const entry = { generation, promise: operation, startedAt: Date.now() };
         orchestrationRefreshes.set(refreshKey, entry);
+        // A timed-out foreground caller must not orphan the operation in the
+        // singleflight map.  Resolve/reject handlers are attached immediately so
+        // the map is cleaned when the provider read eventually settles.
+        void operation.then(() => cleanupOrchestrationRefresh(refreshKey, entry), () => cleanupOrchestrationRefresh(refreshKey, entry));
+        if (options.waitForCompletion)
+            return await operation;
+        let foregroundTimedOut = false;
         try {
             const outcome = await Promise.race([
                 operation.then((result) => ({ kind: "result", result })),
                 new Promise((resolve) => setTimeout(() => resolve({ kind: "timeout" }), orchestrationRefreshMaxWaitMs)),
             ]);
             if (outcome.kind === "timeout") {
-                entry.abandoned = true;
-                if (orchestrationRefreshes.get(refreshKey) === entry)
-                    orchestrationRefreshes.delete(refreshKey);
-                orchestrationRefreshGenerations.set(refreshKey, (orchestrationRefreshGenerations.get(refreshKey) ?? 0) + 1);
-                // The first caller must have the same bounded wait as followers. Drop
-                // the provider client so the old IPC cannot poison the next refresh.
-                void getHeadlessRuntimeManager(session.cwd).invalidateClientForBinding(session.runtimeBinding, session.cwd);
+                foregroundTimedOut = true;
+                // Do not cancel or invalidate the provider client here.  The read is
+                // still the authoritative singleflight for this binding and may
+                // finish successfully after the UI/control request has returned.
                 return sessions.get(session.sessionId) ?? session;
             }
             const result = outcome.result;
             if (!entry.abandoned && generation !== (orchestrationRefreshGenerations.get(refreshKey) ?? 0)) {
                 if (orchestrationRefreshes.get(refreshKey) === entry)
                     orchestrationRefreshes.delete(refreshKey);
-                return await refreshNativeHistoryForLoadedSession(session, config, requestId);
+                return await refreshNativeHistoryForLoadedSession(session, config, requestId, options);
             }
             if (entry.abandoned)
                 return sessions.get(session.sessionId) ?? session;
             return result;
         }
         finally {
-            if (orchestrationRefreshes.get(refreshKey) === entry)
-                orchestrationRefreshes.delete(refreshKey);
+            if (!foregroundTimedOut)
+                cleanupOrchestrationRefresh(refreshKey, entry);
         }
     }
     return await refreshNativeHistory(session, config, requestId, true);

package/apps/daemon/dist/session/prompt.js

@@ -43,12 +43,18 @@ function scheduleNativeHistoryRecovery(ws, config, session, requestId, turnId) {
             return;
         }
         try {
-            // Each attempt gets a fresh provider read. A successful early read can
-            // still precede provider canonicalization, so do not let the refresh
-            // cache suppress the later attempts.
-            invalidateNativeHistoryRefreshForLoadedSession(current);
-            const refreshed = await refreshNativeHistoryForLoadedSession(current, config, `${requestId}:history-recovery:${recovery.attempt}`);
+            // Re-enter the refresh singleflight without cancelling an in-flight
+            // provider read. Native history can be slow on a remote/Windows
+            // provider; the bounded terminal wait must not turn a successful
+            // background read into a repeated cancel/retry loop. A later terminal
+            // generation explicitly invalidates the cache when a genuinely fresh
+            // read is required.
+            const refreshed = await refreshNativeHistoryForLoadedSession(current, config, `${requestId}:history-recovery:${recovery.attempt}`, { waitForCompletion: true });
             const latest = sessions.get(session.sessionId) ?? refreshed;
+            if (sessionTurns.activeTurnId(session.sessionId) || latest.runtimeBinding.threadId !== session.runtimeBinding.threadId) {
+                nativeHistoryRecoveries.delete(key);
+                return;
+            }
             await replaceAuthoritativeTranscript(ws, config, latest, undefined, {
                 replacementKind: "sync",
                 requestId: `${requestId}:history-recovery:${recovery.attempt}`,
@@ -427,7 +433,7 @@ export async function handlePrompt(ws, config, command) {
             // the authoritative transcript, so live projections and subsequent
             // turn.result/status reads converge without a second turn execution.
             invalidateNativeHistoryRefreshForLoadedSession(session);
-            const nativeRefresh = refreshNativeHistoryForLoadedSession(sessions.get(command.sessionId) ?? session, config, command.requestId).catch((error) => {
+            const nativeRefresh = refreshNativeHistoryForLoadedSession(sessions.get(command.sessionId) ?? session, config, command.requestId, { waitForCompletion: true }).catch((error) => {
                 console.error(`Legacy Crew post-turn history refresh failed for ${command.turnId}: ${error instanceof Error ? error.message : String(error)}`);
             });
             // Provider-native history is read-only cleanup.  It must not hold the
@@ -440,10 +446,10 @@ export async function handlePrompt(ws, config, command) {
                 new Promise((resolve) => setTimeout(() => resolve(refreshTimeout), 2_000)),
             ]);
             if (refreshOutcome === refreshTimeout) {
-                // Detach the provider operation at the terminal boundary instead of
-                // leaving a stalled IPC request alive until its much longer transport
-                // timeout. The next official read/recovery pass starts a new generation.
-                invalidateNativeHistoryRefreshForLoadedSession(sessions.get(command.sessionId) ?? session);
+                // Keep the provider operation alive after the short terminal wait.
+                // The refresh layer owns its singleflight and will publish the
+                // provider-canonical transcript when the slow read completes; the
+                // recovery timer below only re-enters that operation if needed.
                 scheduleNativeHistoryRecovery(ws, config, sessions.get(command.sessionId) ?? session, command.requestId, command.turnId);
             }
             session = sessions.get(command.sessionId) ?? session;

package/apps/daemon/dist/session/runtime-truth.js

@@ -17,12 +17,21 @@ export async function runtimeRead(config, input) {
         // Reconcile that history before projecting turn.result/status so an
         // upgrade/restart repairs old same-turn duplicates through the official
         // read path, without requiring an internal syncNativeHistory call.
-        // Event catch-up reads the authoritative Headless event log and must stay
-        // independent from the provider-native history refresh. The latter can
-        // involve a slow/remote provider IPC call; putting it in every polling
-        // page made one stale Crew subscription block all other orchestration.
-        // Result/status/list retain the refresh for legacy native-history repair.
-        if (input.action !== "turn.eventsPage") {
+        // Forward/anchored event catch-up reads the append-only Headless event
+        // log and must stay independent from provider-native refresh: a slow
+        // provider IPC call must not block every subscription poll. An unanchored
+        // first page, however, is the canonical rebuild boundary. Refresh legacy
+        // native-backed sessions there once (the refresh layer single-flights and
+        // caches it) so old same-turn provider duplicates are repaired before the
+        // page is projected. Active turns remain event-only until terminal.
+        const isUnanchoredEventPage = input.action === "turn.eventsPage"
+            && input.after === undefined
+            && input.before === undefined
+            && input.beforeItemId === undefined
+            && input.afterItemId === undefined
+            && !sessionTurns.activeTurnId(input.sessionId)
+            && (session.source === "native" || (session.source === "orchestration" && Boolean(session.providerSessionId)));
+        if (input.action !== "turn.eventsPage" || isUnanchoredEventPage) {
             session = await refreshNativeHistoryForLoadedSession(session, config, `runtime_truth_refresh_${input.requestId}`);
         }
         runtimeSessionId = runtimeSessionIdForSession(session);

package/apps/daemon/package.json

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

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.502",
+  "version": "0.1.0-beta.504",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
-  "buildId": "9ee7dcc44e6e7465aaa011b2c13085c8",
+  "buildId": "d074135e7e6ab20470b2dcf91f68dcdc",
   "type": "module",
   "bin": {
     "happy-elves": "./apps/cli/dist/index.js",

package/packages/headless-runtime/dist/core.js

@@ -575,7 +575,7 @@ export class HeadlessRuntimeCore {
                     .filter((item) => !mappedItemIds.has(item.id))
                     .filter((item) => item.type === "agentMessage" || item.type === "userMessage")
                     .filter((item) => mappedSourceItems.some((sourceItem) => (sourceItem.kind === "assistant" ? item.type === "agentMessage" : item.type === "userMessage")
-                    && item.text === sourceItem.text))
+                    && (item.text === sourceItem.text || nativeUserInputTextEqual(sourceItem, item))))
                     .map((item) => item.id);
                 if (duplicateTextItemIds.length > 0) {
                     removedItemIds.push(...duplicateTextItemIds);
@@ -3094,6 +3094,21 @@ function runtimeTurnIdForProviderTurn(thread, providerTurnId, providerCheckpoint
 function nativeItemBindingKey(providerTurnId, providerItemId) {
     return `${providerTurnId}\0${providerItemId}`;
 }
+/**
+ * Native providers occasionally append a transport newline to a user input
+ * when reopening a turn. Treat that as the same input only at this mapping
+ * boundary: the comparison is turn-scoped, kind-scoped, and one-to-one. We
+ * intentionally do not trim arbitrary whitespace or apply this to assistant
+ * output, so legitimate repeated prompts remain distinct.
+ */
+function nativeUserInputTextEqual(source, projected) {
+    if (source.kind !== "user" || projected.type !== "userMessage" || !("text" in projected))
+        return false;
+    if (projected.text === source.text)
+        return true;
+    const withoutTerminalNewline = (value) => value.replace(/(?:\r\n|\n|\r)+$/g, "");
+    return withoutTerminalNewline(projected.text) === withoutTerminalNewline(source.text);
+}
 /**
  * Map provider-native items onto an existing HE turn projection.
  *
@@ -3141,7 +3156,15 @@ function mapNativeItemsToProjection(sourceItems, existingItems, priorBindings, p
             continue;
         }
         const sourceItem = sourceItems[sourceIndex];
-        const exact = candidateAtOrAfterCursor((item) => item.type === sourceType(sourceItem) && "text" in item && item.text === sourceItem.text);
+        // Prefer the exact provider text before the transport-normalized fallback.
+        // This keeps a stable native item bound to the right projection when a
+        // legacy duplicate and the canonical item are both present. The newline
+        // comparison is only a positional, one-to-one recovery for an otherwise
+        // unbound native item; it is never a global text dedupe.
+        const exact = candidateAtOrAfterCursor((item) => item.type === sourceType(sourceItem) && "text" in item && item.text === sourceItem.text)
+            ?? (sourceItem.kind === "user"
+                ? candidateAtOrAfterCursor((item) => item.type === sourceType(sourceItem) && "text" in item && nativeUserInputTextEqual(sourceItem, item))
+                : undefined);
         if (exact) {
             itemIds[sourceIndex] = exact.item.id;
             usedExisting.add(exact.item.id);
@@ -3188,7 +3211,8 @@ function mapNativeItemsToProjection(sourceItems, existingItems, priorBindings, p
             continue;
         }
         const mappedText = indexes.map((index) => sourceItems[index].text).join("");
-        if (mappedText !== existing.text)
+        const singleUserItem = indexes.length === 1 && sourceItems[indexes[0]]?.kind === "user";
+        if (!(singleUserItem ? nativeUserInputTextEqual(sourceItems[indexes[0]], existing) : mappedText === existing.text))
             valid = false;
     }
     const complete = valid