@cydm/happy-elves 0.1.0-beta.297 → 0.1.0-beta.299

package/apps/cli/dist/commands/lib/session-output.js

@@ -315,7 +315,8 @@ function foldAliasedRuntimeEvents(events) {
     const profiles = new Map();
     const runtimeToRequest = new Map();
     for (const event of events) {
-        const profile = profiles.get(event.turnId) ?? { output: "" };
+        const profile = profiles.get(event.turnId) ?? { output: "", hasDone: false, firstEventId: event.id };
+        profile.firstEventId = Math.min(profile.firstEventId, event.id);
         const payload = event.decoded;
         if (payload?.type === "user_prompt" && profile.prompt === undefined) {
             profile.prompt = payload.text.trim();
@@ -324,6 +325,7 @@ function foldAliasedRuntimeEvents(events) {
             profile.output += payload.text;
         }
         else if (payload?.type === "done") {
+            profile.hasDone = true;
             const runtimeTurnId = payload.lastTurnId ?? payload.currentHead;
             if (runtimeTurnId && runtimeTurnId !== event.turnId && !runtimeTurnId.startsWith("event:")) {
                 runtimeToRequest.set(runtimeTurnId, event.turnId);
@@ -345,11 +347,83 @@ function foldAliasedRuntimeEvents(events) {
             duplicateRuntimeToRequest.set(runtimeTurnId, requestTurnId);
         }
     }
+    const inferredRuntimeToRequest = inferRuntimeToRequestAliases(profiles, runtimeToRequest);
+    const inferredRequestToRuntime = new Map();
+    for (const [runtimeTurnId, requestTurnId] of inferredRuntimeToRequest) {
+        runtimeToRequest.set(runtimeTurnId, requestTurnId);
+        inferredRequestToRuntime.set(requestTurnId, runtimeTurnId);
+    }
+    const foldedEvents = [];
+    for (const event of events) {
+        if (duplicateRuntimeTurns.has(event.turnId))
+            continue;
+        const inferredRequestTurnId = inferredRuntimeToRequest.get(event.turnId);
+        if (inferredRequestTurnId) {
+            foldedEvents.push({ ...event, turnId: inferredRequestTurnId });
+            continue;
+        }
+        const inferredRuntimeTurnId = inferredRequestToRuntime.get(event.turnId);
+        if (inferredRuntimeTurnId && shouldDropRequestSideDuplicateEvent(event, profiles.get(inferredRuntimeTurnId))) {
+            continue;
+        }
+        foldedEvents.push(event);
+    }
     return {
-        events: duplicateRuntimeTurns.size === 0 ? events : events.filter((event) => !duplicateRuntimeTurns.has(event.turnId)),
-        runtimeToRequest: duplicateRuntimeToRequest,
+        events: foldedEvents,
+        runtimeToRequest: new Map([...duplicateRuntimeToRequest, ...inferredRuntimeToRequest]),
     };
 }
+function inferRuntimeToRequestAliases(profiles, explicitRuntimeToRequest) {
+    const requestsByPrompt = new Map();
+    const runtimesByPrompt = new Map();
+    for (const [turnId, profile] of profiles) {
+        const promptKey = comparableOutput(profile.prompt ?? "");
+        if (!promptKey)
+            continue;
+        if (turnId.startsWith("turn_") && !profile.hasDone) {
+            requestsByPrompt.set(promptKey, [...(requestsByPrompt.get(promptKey) ?? []), { turnId, output: profile.output, firstEventId: profile.firstEventId }]);
+        }
+        else if (!turnId.startsWith("turn_") && profile.hasDone && !explicitRuntimeToRequest.has(turnId)) {
+            runtimesByPrompt.set(promptKey, [...(runtimesByPrompt.get(promptKey) ?? []), { turnId, output: profile.output, firstEventId: profile.firstEventId }]);
+        }
+    }
+    const inferred = new Map();
+    for (const [promptKey, requests] of requestsByPrompt) {
+        const runtimes = runtimesByPrompt.get(promptKey) ?? [];
+        if (requests.length !== 1 || runtimes.length !== 1)
+            continue;
+        const request = requests[0];
+        const runtime = runtimes[0];
+        if (!request || !runtime)
+            continue;
+        if (runtime.firstEventId <= request.firstEventId)
+            continue;
+        if (!outputsAreCompatible(request.output, runtime.output))
+            continue;
+        inferred.set(runtime.turnId, request.turnId);
+    }
+    return inferred;
+}
+function outputsAreCompatible(requestOutput, runtimeOutput) {
+    const request = comparableOutput(requestOutput);
+    const runtime = comparableOutput(runtimeOutput);
+    if (!request || !runtime)
+        return true;
+    return request.includes(runtime) || runtime.includes(request);
+}
+function shouldDropRequestSideDuplicateEvent(event, runtimeProfile) {
+    if (!runtimeProfile)
+        return false;
+    const payload = event.decoded;
+    if (payload?.type === "user_prompt") {
+        return comparableOutput(payload.text) === comparableOutput(runtimeProfile.prompt ?? "");
+    }
+    if (payload?.type === "text_delta" && payload.stream !== "thought" && payload.text) {
+        const chunk = comparableOutput(payload.text);
+        return Boolean(chunk) && comparableOutput(runtimeProfile.output).includes(chunk);
+    }
+    return false;
+}
 function dedupeSyntheticHistoricalEvents(events) {
     const groups = new Map();
     for (const event of events) {

package/apps/cli/package.json

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

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

@@ -1,4 +1,4 @@
-import { normalizeSessionName } from "../../../../packages/shared/dist/index.js";
+import { normalizeSessionName, normalizeSessionTags } from "../../../../packages/shared/dist/index.js";
 import { appendAudit } from "../audit.js";
 import { getRuntime } from "../runtime.js";
 import { sessions } from "../state.js";
@@ -16,6 +16,7 @@ export async function handleCreateSession(ws, config, command) {
     try {
         const metadata = await commandSessionMetadata(config, command.encryptedMetadata);
         const model = modelFromCommand(command.model ?? metadata?.model);
+        const tags = normalizeSessionTags(metadata?.tags);
         const runtime = getRuntime(cwd);
         let handle = await runtime.ensureSession({
             sessionKey: command.sessionId,
@@ -42,6 +43,7 @@ export async function handleCreateSession(ws, config, command) {
             cwd,
             name: providerName ?? command.name,
             ...(model ? { model } : {}),
+            ...(tags.length > 0 ? { tags } : {}),
             handle,
         };
         sessions.set(command.sessionId, state);
@@ -257,7 +259,12 @@ function historicalSessionPage(value) {
 export async function resumeSession(ws, config, sessionId, requestId, fallback, announceSuccess = true, syncDirection = "auto") {
     const existing = sessions.get(sessionId);
     if (existing) {
-        const refreshed = await refreshRuntimeSessionName(existing);
+        const hydratedExisting = fallback?.tags && fallback.tags.length > 0
+            ? { ...existing, tags: fallback.tags }
+            : existing;
+        if (hydratedExisting !== existing)
+            sessions.set(sessionId, hydratedExisting);
+        const refreshed = await refreshRuntimeSessionName(hydratedExisting);
         const nameChanged = refreshed.name !== existing.name;
         const backfill = await backfillHistoricalEvents(ws, config, refreshed, undefined, refreshed.historicalBackfill ?? fallback?.historicalBackfill, {
             direction: syncDirection,
@@ -308,7 +315,14 @@ export async function resumeSession(ws, config, sessionId, requestId, fallback,
             cwd,
             restartableEmptySession: fallback?.emptyRuntimeSession === true,
         });
-        const state = await refreshRuntimeSessionName({ sessionId, agent, cwd, name, handle });
+        const state = await refreshRuntimeSessionName({
+            sessionId,
+            agent,
+            cwd,
+            name,
+            ...(fallback?.tags && fallback.tags.length > 0 ? { tags: fallback.tags } : {}),
+            handle,
+        });
         sessions.set(sessionId, state);
         const nameChanged = state.name !== name;
         const backfill = await backfillHistoricalEvents(ws, config, state, resumeSessionId, fallback?.historicalBackfill, {

package/apps/daemon/dist/session/metadata.d.ts

@@ -1,6 +1,6 @@
 import { type EncryptedEnvelope, type MachineCommand } from "../../../../packages/shared/dist/index.js";
 import type { DaemonConfig, SessionFallback, SessionMetadata, SessionState } from "../types.js";
-export declare function encryptedSessionMetadata(config: DaemonConfig, sessionId: string, state: Pick<SessionState, "agent" | "cwd" | "name" | "handle" | "model">, extra: Record<string, unknown>): Promise<EncryptedEnvelope>;
+export declare function encryptedSessionMetadata(config: DaemonConfig, sessionId: string, state: Pick<SessionState, "agent" | "cwd" | "name" | "handle" | "model" | "tags">, extra: Record<string, unknown>): Promise<EncryptedEnvelope>;
 export declare function commandSessionMetadata(config: DaemonConfig, encryptedMetadata?: EncryptedEnvelope): Promise<SessionMetadata | undefined>;
 export declare function sessionFallbackFromCommand(config: DaemonConfig, command: Extract<MachineCommand, {
     type: "machine:prompt" | "machine:resume" | "machine:rewind" | "machine:fork" | "machine:renameSession" | "machine:close";

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

@@ -1,10 +1,11 @@
-import { decryptJson, encryptJson } from "../../../../packages/shared/dist/index.js";
+import { decryptJson, encryptJson, normalizeSessionTags, sessionTagKeys } from "../../../../packages/shared/dist/index.js";
 export function encryptedSessionMetadata(config, sessionId, state, extra) {
     return encryptJson(config.accountSecret, `session:${sessionId}:metadata`, {
         agent: state.agent,
         cwd: state.cwd,
         name: state.name,
         ...(state.model ? { model: state.model } : {}),
+        ...(state.tags && state.tags.length > 0 ? { tags: state.tags, tagKeys: sessionTagKeys(state.tags) } : {}),
         runtime: {
             backend: state.handle.backend,
             runtimeSessionName: state.handle.runtimeSessionName,
@@ -33,11 +34,13 @@ export async function sessionFallbackFromCommand(config, command) {
         return undefined;
     try {
         const metadata = await decryptJson(config.accountSecret, encryptedMetadata);
+        const tags = safeSessionTags(metadata.tags);
         return {
             agent: metadata.agent ?? "codex",
             cwd: metadata.cwd || process.cwd(),
             name: metadata.name ?? command.sessionId,
             ...(typeof metadata.model === "string" && metadata.model.trim() ? { model: metadata.model.trim() } : {}),
+            ...(tags.length > 0 ? { tags } : {}),
             emptyRuntimeSession: metadata.emptyRuntimeSession === true,
             historicalBackfill: historicalBackfillStateFromMetadata(metadata),
             runtime: metadata.runtime,
@@ -47,6 +50,14 @@ export async function sessionFallbackFromCommand(config, command) {
         return undefined;
     }
 }
+function safeSessionTags(value) {
+    try {
+        return normalizeSessionTags(Array.isArray(value) ? value : undefined);
+    }
+    catch {
+        return [];
+    }
+}
 function historicalBackfillStateFromMetadata(metadata) {
     const status = historicalBackfillStatus(metadata.historicalBackfillStatus ?? metadata.historicalBackfill);
     const totalEvents = nonNegativeInteger(metadata.historicalBackfillTotalEvents ?? metadata.availableHistoricalEvents);

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

@@ -54,9 +54,10 @@ export async function handleRewind(ws, config, command) {
         return;
     if (!claimCommandRequest(ws, command.requestId))
         return;
-    const session = sessions.get(command.sessionId) ?? (await resumeSession(ws, config, command.sessionId, command.requestId, await sessionFallbackFromCommand(config, command), false));
+    let session = sessions.get(command.sessionId) ?? (await resumeSession(ws, config, command.sessionId, command.requestId, await sessionFallbackFromCommand(config, command), false));
     if (!session)
         return;
+    session = await hydrateSessionTagsFromCommand(config, command, session);
     const runtimeWithPrimitives = getRuntime(session.cwd);
     if (typeof runtimeWithPrimitives.rewindSession !== "function") {
         await emitCapabilityUnavailable(ws, config, command, "session.rewind", true);
@@ -222,14 +223,16 @@ export async function handleFork(ws, config, command) {
         });
         return;
     }
+    const sourceMetadata = await commandSessionMetadata(config, command.sourceEncryptedMetadata);
+    const targetMetadata = await commandSessionMetadata(config, command.encryptedMetadata);
     const forkState = {
         sessionId: command.targetSessionId,
         agent: source.agent,
         cwd: source.cwd,
         name: command.name,
+        ...(targetMetadata?.tags && targetMetadata.tags.length > 0 ? { tags: targetMetadata.tags } : {}),
         handle: forkHandle,
     };
-    const sourceMetadata = await commandSessionMetadata(config, command.sourceEncryptedMetadata);
     sessions.set(command.targetSessionId, forkState);
     await appendAudit({
         sessionId: command.sessionId,
@@ -323,9 +326,10 @@ export async function handleRename(ws, config, command) {
         });
         return;
     }
-    const session = sessions.get(command.sessionId) ?? (await resumeSession(ws, config, command.sessionId, command.requestId, await sessionFallbackFromCommand(config, command), false));
+    let session = sessions.get(command.sessionId) ?? (await resumeSession(ws, config, command.sessionId, command.requestId, await sessionFallbackFromCommand(config, command), false));
     if (!session)
         return;
+    session = await hydrateSessionTagsFromCommand(config, command, session);
     const runtimeWithPrimitives = getRuntime(session.cwd);
     if (typeof runtimeWithPrimitives.renameSession !== "function") {
         await emitCapabilityUnavailable(ws, config, command, "session.rename", true);
@@ -389,6 +393,14 @@ function capabilityUnavailableEvidence(command) {
         return { requestId: command.requestId, nameLength: command.name.length };
     return { requestId: command.requestId, from: command.from, targetSessionId: command.targetSessionId, name: command.name };
 }
+async function hydrateSessionTagsFromCommand(config, command, session) {
+    const metadata = await commandSessionMetadata(config, command.encryptedMetadata);
+    if (!metadata?.tags || metadata.tags.length === 0)
+        return session;
+    const next = { ...session, tags: metadata.tags };
+    sessions.set(session.sessionId, next);
+    return next;
+}
 function primitiveRuntimeEvidence(previous, next) {
     return {
         runtime: {

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

@@ -25,14 +25,19 @@ export async function handlePrompt(ws, config, command) {
     }
     if (activePromptRequests.has(command.requestId))
         return;
-    const session = sessions.get(command.sessionId);
+    const fallback = await sessionFallbackFromCommand(config, command);
+    let session = sessions.get(command.sessionId);
     if (!session) {
-        const resumed = await resumeSession(ws, config, command.sessionId, command.requestId, await sessionFallbackFromCommand(config, command), false);
+        const resumed = await resumeSession(ws, config, command.sessionId, command.requestId, fallback, false);
         if (!resumed)
             return;
         await handlePrompt(ws, config, command);
         return;
     }
+    if (fallback?.tags && fallback.tags.length > 0) {
+        session = { ...session, tags: fallback.tags };
+        sessions.set(command.sessionId, session);
+    }
     if (!claimSessionTurn(command.sessionId, command.requestId, command.turnId, "prompt")) {
         await sendCommandResponse(ws, {
             type: "machine:error",

package/apps/daemon/dist/types.d.ts

@@ -32,6 +32,7 @@ export type SessionState = {
     cwd: string;
     name: string;
     model?: string;
+    tags?: string[];
     handle: RuntimeHandle;
     historicalBackfill?: HistoricalBackfillState;
 };
@@ -55,6 +56,8 @@ export type SessionMetadata = {
     name?: string;
     providerName?: string;
     model?: string;
+    tags?: string[];
+    tagKeys?: string[];
     requestedRuntimeName?: string;
     permissionMode?: PermissionMode;
     importedFromRuntimeSessionId?: string;
@@ -86,6 +89,7 @@ export type SessionMetadata = {
 };
 export type SessionFallback = Pick<SessionState, "agent" | "cwd" | "name"> & {
     model?: string;
+    tags?: string[];
     emptyRuntimeSession?: boolean;
     historicalBackfill?: HistoricalBackfillState;
     runtime?: SessionMetadata["runtime"];

package/apps/daemon/package.json

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

package/apps/relay/dist/machine-handlers.js

@@ -588,7 +588,7 @@ export function handleMachineMessage(context, connection, message) {
             return;
         }
         const row = result.session ?? db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
-        if (row)
+        if (row && row.status !== "closed")
             broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
         acknowledgeMachineMessage();
         return;
@@ -813,6 +813,8 @@ function applySessionHeadAdvance(db, input, ts) {
         .get(input.sessionId, input.accountId, input.machineId);
     if (!sessionRow)
         return { status: "session-not-found" };
+    if (sessionRow.status === "closed")
+        return { status: "noop", session: sessionRow };
     const basisEvent = resolveHeadAdvanceBasisEvent(db, input.accountId, input.sessionId, input.machineId, input.basis);
     if (!basisEvent)
         return { status: "missing", session: sessionRow };
@@ -834,7 +836,10 @@ function applySessionHeadAdvance(db, input, ts) {
         sessionRow.status === "running" &&
         comparison === 0 &&
         currentHeadAlreadySettled;
-    if (!shouldAdvance && !shouldSettleStatus)
+    const shouldRefreshMetadata = !rewriteFenced &&
+        input.encryptedMetadata !== undefined &&
+        currentHeadAlreadySettled;
+    if (!shouldAdvance && !shouldSettleStatus && !shouldRefreshMetadata)
         return { status: "noop", session: sessionRow };
     db.prepare(`UPDATE sessions
      SET status = COALESCE(?, status),

package/package.json

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

package/packages/client/dist/client.js

@@ -7,6 +7,7 @@ import { sendAndWaitForDirectoryListing, sendAndWaitForFilePreview, sendAndWaitF
 import { DEFAULT_SESSION_CREATE_WAIT_MS, } from "./types.js";
 import { isWaitCondition, matchesWaitCondition, parseEventCursor, parseEventLimit, parsePositiveDuration, requireNonEmpty, sleep, } from "./validation.js";
 const DEFAULT_BLOCKING_RUN_WAIT_MS = 30 * 60 * 1000;
+const RESUME_COMMAND_TIMEOUT_MS = 60_000;
 function addRuntimeSessionId(ids, value) {
     if (typeof value === "string" && value.trim())
         ids.add(value.trim());
@@ -368,7 +369,7 @@ export class ControllerClient {
             requestId,
             sessionId: checkedSessionId,
             ...(options.syncDirection ? { syncDirection: options.syncDirection } : {}),
-        });
+        }, false, RESUME_COMMAND_TIMEOUT_MS);
     }
     async listHistoricalSessionsPage(input) {
         const machineId = requireNonEmpty(input.machineId, "machineId");