@cydm/happy-elves 0.1.0-beta.500 → 0.1.0-beta.501

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.500
-    npm.cmd exec --yes --package @cydm/happy-elves@0.1.0-beta.500 -- 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.501
+    npm.cmd exec --yes --package @cydm/happy-elves@0.1.0-beta.501 -- 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.500",
+  "version": "0.1.0-beta.501",
   "private": true,
   "type": "module"
 }

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

@@ -10,7 +10,7 @@ import { rehydrateRuntimeSession } from "../session/lifecycle.js";
 import { runtimeRead } from "../session/runtime-truth.js";
 import { encryptedSessionMetadata } from "../session/metadata.js";
 import { loadSessionProjections } from "../session/store.js";
-import { appendAttention, expireInflightLeases, leaseNextAttention, latestAttentionForTask, markAttentionDelivered, markAttentionDeliveryFailed, markSubscriptionLiveness, recordTurnRuntimeBinding, reopenUnresolvedArtifactFeedbackAttentions, readOrchestrationStore, } from "./store.js";
+import { appendAttention, closeSubscriptionForTurn, expireInflightLeases, leaseNextAttention, latestAttentionForTask, markAttentionDelivered, markAttentionDeliveryFailed, markSubscriptionLiveness, recordTurnRuntimeBinding, reopenUnresolvedArtifactFeedbackAttentions, readOrchestrationStore, } from "./store.js";
 import { attentionFromReconcile, catchUpSubscriptionEvents } from "./watcher.js";
 import { scheduleRemoteOrchestrationWork } from "./remote-work-budget.js";
 import { resolveWakeIdentity } from "./wake-identity.js";
@@ -146,9 +146,6 @@ async function reconcileSubscriptionsOnce(config) {
         if (reconciledSubscriptions.has(key))
             continue;
         reconciledSubscriptions.add(key);
-        const latest = await latestAttentionForTask(subscription.taskId);
-        if (latest?.eventTypes.some((type) => type === "terminal" || type === "failure"))
-            continue;
         if (crewMachineId !== config.machineId) {
             // Remote reconcile shares the same bounded/fair scheduler as transcript
             // catch-up. Startup recovery must not create an unbounded second fleet
@@ -252,8 +249,20 @@ async function reconcileRemoteSubscription(config, subscription) {
             return;
         }
         const attention = attentionFromReconcile(result);
-        if (!attention || !subscription.eventTypes.includes(attention.eventType))
+        if (!attention)
             return;
+        const closesTurn = attention.eventType === "terminal" || attention.eventType === "failure";
+        if (!subscription.eventTypes.includes(attention.eventType)) {
+            if (closesTurn) {
+                await closeSubscriptionForTurn({
+                    taskId: subscription.taskId,
+                    consumerSessionId: subscription.consumerSessionId,
+                    crewSessionId: subscription.crewSessionId,
+                    turnId: subscription.turnId,
+                });
+            }
+            return;
+        }
         await appendAttention({
             taskId: subscription.taskId,
             consumerMachineId: subscription.consumerMachineId ?? config.machineId,
@@ -270,6 +279,7 @@ async function reconcileRemoteSubscription(config, subscription) {
                 turnId: subscription.turnId,
                 ref: result.status,
             },
+            closeSubscription: closesTurn,
         });
     }
     catch (error) {
@@ -307,14 +317,16 @@ async function markStaleSubscriptions(config) {
         if (Number.isFinite(lastSeenAt) && now - lastSeenAt < staleMs)
             continue;
         const latest = await latestAttentionForTask(subscription.taskId);
-        if (latest?.eventTypes.some((type) => type === "terminal" || type === "failure"))
-            continue;
-        if (latest?.eventTypes.includes("stale") && latest.status !== "acked")
+        if (latest?.turnId === subscription.turnId && latest.eventTypes.includes("stale") && latest.status !== "acked")
             continue;
         if ((subscription.crewMachineId ?? config.machineId) === config.machineId) {
             await reconcileLocalSubscription(config, subscription, "stale-check");
-            const reconciledLatest = await latestAttentionForTask(subscription.taskId);
-            if (reconciledLatest?.eventTypes.some((type) => type === "terminal" || type === "failure" || type === "unknown"))
+            const reconciledStore = await readOrchestrationStore();
+            const currentSubscription = reconciledStore.subscriptions.find((record) => record.taskId === subscription.taskId &&
+                record.consumerSessionId === subscription.consumerSessionId &&
+                record.crewSessionId === subscription.crewSessionId &&
+                record.turnId === subscription.turnId);
+            if (!currentSubscription || currentSubscription.status !== "active")
                 continue;
             if (await localSubscriptionTurnIsActive(subscription))
                 continue;

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

@@ -123,6 +123,8 @@ export type AttentionInput = {
     eventType: TaskAttentionEventType;
     reason: string;
     payloadRef?: TaskAttentionPayloadRef;
+    /** Terminal/failure attention closes the exact turn subscription atomically. */
+    closeSubscription?: boolean;
     now?: string;
 };
 export declare function readOrchestrationStore(): Promise<OrchestrationStore>;
@@ -249,6 +251,9 @@ export declare function markSubscriptionRemoteScan(taskId: string, input: {
     at?: string;
 }): Promise<void>;
 export declare function appendAttention(input: AttentionInput): Promise<TaskAttentionRecord[]>;
+export declare function closeSubscriptionForTurn(input: Pick<AttentionInput, "taskId" | "consumerSessionId" | "crewSessionId" | "turnId"> & {
+    at?: string;
+}): Promise<void>;
 export declare function listAttentions(input?: {
     consumerSessionId?: string;
     status?: TaskAttentionStatus[];

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

@@ -794,6 +794,9 @@ export async function appendAttention(input) {
     let updated;
     const store = await updateOrchestrationStore((current) => {
         updated = appendAttentionRecord(current, { ...input, now: input.now ?? new Date().toISOString() });
+        if (input.closeSubscription && (input.eventType === "terminal" || input.eventType === "failure")) {
+            closeSubscriptionForTurnRecord(current, input);
+        }
         return current;
     });
     if (!updated)
@@ -802,6 +805,30 @@ export async function appendAttention(input) {
         record.consumerSessionId === updated?.consumerSessionId &&
         record.eventCursor === updated?.eventCursor);
 }
+export async function closeSubscriptionForTurn(input) {
+    if (!input.turnId)
+        return;
+    const at = input.at ?? new Date().toISOString();
+    await updateOrchestrationStore((current) => {
+        closeSubscriptionForTurnRecord(current, { ...input, now: at });
+        return current;
+    });
+}
+function closeSubscriptionForTurnRecord(store, input) {
+    if (!input.turnId)
+        return;
+    const now = input.now ?? new Date().toISOString();
+    for (const subscription of store.subscriptions) {
+        if (subscription.status !== "active")
+            continue;
+        if (subscription.taskId !== input.taskId || subscription.consumerSessionId !== input.consumerSessionId)
+            continue;
+        if (subscription.crewSessionId !== input.crewSessionId || subscription.turnId !== input.turnId)
+            continue;
+        subscription.status = "deleted";
+        subscription.updatedAt = now;
+    }
+}
 function appendAttentionRecord(store, input) {
     const index = store.attentions.findIndex((record) => record.taskId === input.taskId && record.consumerSessionId === input.consumerSessionId);
     const payloadRefs = input.payloadRef ? [input.payloadRef] : [];

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

@@ -2,7 +2,7 @@ import { randomId, } from "../../../../packages/shared/dist/index.js";
 import { appendAudit } from "../audit.js";
 import { RemoteCommandError, requestRemoteMachineResult } from "../relay/remote-command.js";
 import { runtimeRead } from "../session/runtime-truth.js";
-import { activeSubscriptionsForTurn, appendAttention, markSubscriptionLiveness, markSubscriptionRemoteScan, recordTurnRuntimeBinding, } from "./store.js";
+import { activeSubscriptionsForTurn, appendAttention, closeSubscriptionForTurn, markSubscriptionLiveness, markSubscriptionRemoteScan, recordTurnRuntimeBinding, } from "./store.js";
 import { scheduleRemoteOrchestrationWork } from "./remote-work-budget.js";
 import { relayMachineRegistry } from "../state.js";
 const remoteCatchupsInFlight = new Map();
@@ -21,8 +21,18 @@ export async function observeSessionEvent(input) {
     }
     const subscriptions = await activeSubscriptionsForTurn(input.sessionId, input.turnId);
     for (const subscription of subscriptions) {
-        if (!subscription.eventTypes.includes(attention.eventType))
+        const closesTurn = attention.eventType === "terminal" || attention.eventType === "failure";
+        if (!subscription.eventTypes.includes(attention.eventType)) {
+            if (closesTurn) {
+                await closeSubscriptionForTurn({
+                    taskId: subscription.taskId,
+                    consumerSessionId: subscription.consumerSessionId,
+                    crewSessionId: subscription.crewSessionId,
+                    turnId: subscription.turnId,
+                });
+            }
             continue;
+        }
         await appendAttention({
             taskId: subscription.taskId,
             consumerMachineId: subscription.consumerMachineId ?? input.config.machineId,
@@ -39,6 +49,7 @@ export async function observeSessionEvent(input) {
                 turnId: input.turnId,
                 eventSeq: input.seq,
             },
+            closeSubscription: closesTurn,
         });
         await appendOrchestrationAudit(input.config, "orchestration.attention.append", `Recorded ${attention.eventType} attention for ${subscription.taskId}`, {
             taskId: subscription.taskId,
@@ -89,6 +100,7 @@ export async function observeTurnReconcile(input) {
                 turnId: input.result.turnId,
                 ref: input.result.status,
             },
+            closeSubscription: attention.eventType === "terminal" || attention.eventType === "failure",
         });
         await appendOrchestrationAudit(input.config, "orchestration.attention.reconcile", `Recorded ${attention.eventType} reconcile attention for ${subscription.taskId}`, {
             taskId: subscription.taskId,
@@ -360,8 +372,18 @@ async function observeSubscriptionPayload(input) {
         }
         return;
     }
-    if (!input.subscription.eventTypes.includes(attention.eventType))
+    const closesTurn = attention.eventType === "terminal" || attention.eventType === "failure";
+    if (!input.subscription.eventTypes.includes(attention.eventType)) {
+        if (closesTurn) {
+            await closeSubscriptionForTurn({
+                taskId: input.subscription.taskId,
+                consumerSessionId: input.subscription.consumerSessionId,
+                crewSessionId: input.subscription.crewSessionId,
+                turnId: input.subscription.turnId,
+            });
+        }
         return;
+    }
     await appendAttention({
         taskId: input.subscription.taskId,
         consumerMachineId: input.subscription.consumerMachineId ?? input.config.machineId,
@@ -378,6 +400,7 @@ async function observeSubscriptionPayload(input) {
             turnId: input.subscription.turnId,
             eventSeq: input.seq,
         },
+        closeSubscription: closesTurn,
     });
     await appendOrchestrationAudit(input.config, "orchestration.attention.append", `Recorded ${input.crewMachineId === input.config.machineId ? "" : "remote "}${attention.eventType} attention for ${input.subscription.taskId}`, {
         taskId: input.subscription.taskId,

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

@@ -703,10 +703,37 @@ export async function connectOnce(config) {
     let loopTimer;
     let scheduleTimer;
     let orchestrationTimer;
+    let authenticated = false;
+    const startAuthenticatedWork = () => {
+        if (!authenticated || ws.readyState !== WebSocket.OPEN)
+            return;
+        if (loopTimer || scheduleTimer || orchestrationTimer)
+            return;
+        const onlineSinceMs = Date.now();
+        loopTimer = setInterval(() => {
+            void tickLoops(ws, config).catch((error) => {
+                console.error(`Loop tick failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, 1000);
+        scheduleTimer = setInterval(() => {
+            void tickSchedules(config, onlineSinceMs).catch((error) => {
+                console.error(`Schedule tick failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, 1000);
+        orchestrationTimer = setInterval(() => {
+            void tickOrchestration(config).catch((error) => {
+                console.error(`Orchestration tick failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, 1000);
+        void recoverCrewQueues(config).catch((error) => {
+            console.error(`Crew queue relay-open recovery failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        void drainPendingArtifactFeedbackAttentions(config).catch((error) => {
+            console.error(`Artifact feedback attention relay-open recovery failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    };
     await new Promise((resolve) => {
         ws.addEventListener("open", () => {
-            const onlineSinceMs = Date.now();
-            setActiveRelaySocket(ws);
             const hello = {
                 type: "hello",
                 token: config.machineToken,
@@ -714,27 +741,6 @@ export async function connectOnce(config) {
                 nodeId: config.machineId,
             };
             ws.send(JSON.stringify(hello));
-            loopTimer = setInterval(() => {
-                void tickLoops(ws, config).catch((error) => {
-                    console.error(`Loop tick failed: ${error instanceof Error ? error.message : String(error)}`);
-                });
-            }, 1000);
-            scheduleTimer = setInterval(() => {
-                void tickSchedules(config, onlineSinceMs).catch((error) => {
-                    console.error(`Schedule tick failed: ${error instanceof Error ? error.message : String(error)}`);
-                });
-            }, 1000);
-            orchestrationTimer = setInterval(() => {
-                void tickOrchestration(config).catch((error) => {
-                    console.error(`Orchestration tick failed: ${error instanceof Error ? error.message : String(error)}`);
-                });
-            }, 1000);
-            void recoverCrewQueues(config).catch((error) => {
-                console.error(`Crew queue relay-open recovery failed: ${error instanceof Error ? error.message : String(error)}`);
-            });
-            void drainPendingArtifactFeedbackAttentions(config).catch((error) => {
-                console.error(`Artifact feedback attention relay-open recovery failed: ${error instanceof Error ? error.message : String(error)}`);
-            });
         });
         ws.addEventListener("message", (event) => {
             let message;
@@ -745,11 +751,24 @@ export async function connectOnce(config) {
                 console.error(`Invalid relay message: ${error instanceof Error ? error.message : String(error)}`);
                 return;
             }
-            void handleRelayWireMessage(ws, config, message).catch(async (error) => {
+            void (async () => {
+                if (message.type === "server:hello" && !authenticated) {
+                    // Relay authentication is complete only after the server hello.
+                    // Do not activate the socket earlier: a reconnect with a durable
+                    // outbox would otherwise flush publishPacket before the relay has
+                    // installed the machine's authenticated routing context.
+                    authenticated = true;
+                    setActiveRelaySocket(ws);
+                }
+                await handleRelayWireMessage(ws, config, message);
+                if (message.type === "server:hello")
+                    startAuthenticatedWork();
+            })().catch(async (error) => {
                 await appendUnscopedRelayError(config, "DAEMON_COMMAND_FAILED", error);
             });
         });
         ws.addEventListener("close", () => {
+            authenticated = false;
             clearActiveRelaySocket(ws);
             if (loopTimer)
                 clearInterval(loopTimer);
@@ -761,6 +780,7 @@ export async function connectOnce(config) {
             resolve();
         });
         ws.addEventListener("error", () => {
+            authenticated = false;
             clearActiveRelaySocket(ws);
             if (loopTimer)
                 clearInterval(loopTimer);

package/apps/daemon/package.json

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

package/apps/updater/dist/daemon.js

@@ -6,6 +6,7 @@ import { promisify } from "node:util";
 import { updaterPaths } from "./paths.js";
 import { daemonControlRequest } from "./control.js";
 import { readUpdaterMarker, readUpdaterOwner } from "./ownership.js";
+import { managedProcessEnvironment } from "./managed-environment.js";
 const execFileAsync = promisify(execFile);
 export async function localDaemonStatus(stateRoot) {
     const file = updaterPaths(stateRoot).daemonPidPath;
@@ -91,7 +92,7 @@ export async function startDaemon(input) {
     const stderr = fsSync.openSync(paths.daemonStderrPath, "a", 0o600);
     const child = spawn(input.nodeExecutable, [input.daemonEntrypoint, "start"], {
         cwd: input.stateRoot,
-        env: { ...process.env, HAPPY_ELVES_HOME: input.stateRoot, HAPPY_ELVES_UPDATER_GENERATION: input.generation },
+        env: { ...managedProcessEnvironment(), HAPPY_ELVES_HOME: input.stateRoot, HAPPY_ELVES_UPDATER_GENERATION: input.generation },
         detached: true,
         stdio: ["ignore", stdout, stderr],
         windowsHide: true,
@@ -119,7 +120,7 @@ export function spawnUpdaterFromStableLauncher(input) {
     const child = spawn(input.nodeExecutable, [runtimeScript, "updater", "run", "--state-root", input.stateRoot], {
         cwd: input.stateRoot,
         env: {
-            ...process.env,
+            ...managedProcessEnvironment(),
             HAPPY_ELVES_HOME: input.stateRoot,
             ...(input.handoffFromPid ? { HAPPY_ELVES_UPDATER_HANDOFF_FROM: String(input.handoffFromPid) } : {}),
             ...(input.handoffToken ? { HAPPY_ELVES_UPDATER_HANDOFF_TOKEN: input.handoffToken } : {}),

package/apps/updater/dist/managed-environment.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Read the current user's Windows environment without making it part of any
+ * host-job request. A manager can itself be launched by a deliberately
+ * sanitized host job; in that case process.env no longer contains provider
+ * credentials that the normal user-launched daemon would inherit.
+ *
+ * The result is used only for manager-owned updater/daemon children. It is
+ * never logged, persisted, sent over Relay, or passed to arbitrary host jobs.
+ */
+export declare function managedProcessEnvironment(base?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, userEnvironment?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function parseWindowsUserEnvironment(output: string, expansionEnvironment?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;

package/apps/updater/dist/managed-environment.js

@@ -0,0 +1,125 @@
+import { execFileSync } from "node:child_process";
+const environmentLookupTimeoutMs = 2_000;
+/**
+ * Read the current user's Windows environment without making it part of any
+ * host-job request. A manager can itself be launched by a deliberately
+ * sanitized host job; in that case process.env no longer contains provider
+ * credentials that the normal user-launched daemon would inherit.
+ *
+ * The result is used only for manager-owned updater/daemon children. It is
+ * never logged, persisted, sent over Relay, or passed to arbitrary host jobs.
+ */
+export function managedProcessEnvironment(base = process.env, platform = process.platform, userEnvironment = platform === "win32" ? readWindowsUserEnvironment(base) : {}) {
+    if (platform !== "win32")
+        return { ...base };
+    const result = { ...base };
+    for (const [key, value] of Object.entries(userEnvironment)) {
+        if (!key || value === undefined || hasEnvironmentKey(result, key))
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+export function parseWindowsUserEnvironment(output, expansionEnvironment = {}) {
+    const entries = new Map();
+    const trimmed = output.trim();
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            for (const [key, value] of Object.entries(parsed)) {
+                if (!key)
+                    continue;
+                if (typeof value === "string")
+                    entries.set(key, { value, expand: false });
+                else if (value && typeof value === "object" && "value" in value && typeof value.value === "string") {
+                    const typedValue = value;
+                    entries.set(key, { value: typedValue.value, expand: isExpandableRegistryType(typedValue.type) });
+                }
+            }
+            return materializeEnvironment(entries, expansionEnvironment);
+        }
+        catch {
+            // Fall through to the line-oriented reg.exe parser.
+        }
+    }
+    for (const line of output.split(/\r?\n/u)) {
+        // `reg query HKCU\\Environment` prints:
+        //     NAME    REG_SZ    value
+        const match = /^\s{4,}([^\s]+)\s+(REG_[A-Z0-9_]+)\s*(.*)$/u.exec(line);
+        if (!match)
+            continue;
+        const [, key, type, rawValue] = match;
+        if (!key || !rawValue)
+            continue;
+        entries.set(key, { value: rawValue, expand: isExpandableRegistryType(type) });
+    }
+    return materializeEnvironment(entries, expansionEnvironment);
+}
+function isExpandableRegistryType(type) {
+    if (typeof type !== "string")
+        return false;
+    const normalized = type.trim().toUpperCase().replace(/[-_\s]/gu, "");
+    // PowerShell's RegistryValueKind.ToString() returns ExpandString, while
+    // reg.exe uses REG_EXPAND_SZ. Both describe the same registry semantics.
+    return normalized === "EXPANDSTRING" || normalized === "REGEXPANDSZ";
+}
+function readWindowsUserEnvironment(base) {
+    try {
+        const output = execFileSync("powershell.exe", [
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-Command",
+            "$ErrorActionPreference='Stop'; $OutputEncoding=New-Object System.Text.UTF8Encoding($false); [Console]::OutputEncoding=New-Object System.Text.UTF8Encoding($false); $k=[Microsoft.Win32.Registry]::CurrentUser.OpenSubKey('Environment'); if ($null -eq $k) { '{}' } else { $o=[ordered]@{}; foreach ($n in $k.GetValueNames()) { $o[$n]=[ordered]@{ value=[string]$k.GetValue($n,$null,[Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames); type=$k.GetValueKind($n).ToString() } }; $o | ConvertTo-Json -Compress; $k.Dispose() }",
+        ], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            windowsHide: true,
+            timeout: environmentLookupTimeoutMs,
+        });
+        return parseWindowsUserEnvironment(output, base);
+    }
+    catch {
+        try {
+            const output = execFileSync("reg.exe", ["query", "HKCU\\Environment"], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+                windowsHide: true,
+                timeout: environmentLookupTimeoutMs,
+            });
+            return parseWindowsUserEnvironment(output, base);
+        }
+        catch {
+            // A missing registry helper or a locked-down profile must not prevent
+            // the updater from starting. The daemon will surface a provider error
+            // if it genuinely needs a credential that is unavailable in its env.
+            return {};
+        }
+    }
+}
+function materializeEnvironment(entries, expansionEnvironment) {
+    const result = {};
+    const combined = { ...expansionEnvironment };
+    for (const [key, entry] of entries)
+        combined[key] = entry.value;
+    for (const [key, entry] of entries) {
+        result[key] = entry.expand ? expandWindowsVariables(entry.value, combined) : entry.value;
+    }
+    return result;
+}
+function hasEnvironmentKey(environment, key) {
+    if (Object.hasOwn(environment, key))
+        return true;
+    const normalized = key.toUpperCase();
+    return Object.keys(environment).some((candidate) => candidate.toUpperCase() === normalized);
+}
+function expandWindowsVariables(value, environment) {
+    return value.replace(/%([^%]+)%/gu, (match, name) => {
+        const direct = environment[name];
+        if (direct !== undefined)
+            return direct;
+        const existing = Object.entries(environment).find(([key]) => key.toUpperCase() === name.toUpperCase());
+        return existing?.[1] ?? match;
+    });
+}
+//# sourceMappingURL=managed-environment.js.map

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.500",
+  "version": "0.1.0-beta.501",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
-  "buildId": "48f1f04bc7d6747ed2bf59b3fb1e2a58",
+  "buildId": "4edbb3ee3e6735ee0abb55e9b0612b17",
   "type": "module",
   "bin": {
     "happy-elves": "./apps/cli/dist/index.js",