@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

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

@@ -1,10 +1,10 @@
-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";
 import { claimCommandRequest, sendCommandResponse } from "../relay/send.js";
 import { createSessionFailureAuditEvent, createSessionFailureResponse } from "./create-session.js";
-import { emitHistoricalEvents, emitRuntimeTailEvents, emitTranscriptPrepended, emitTranscriptReplacement } from "./events.js";
+import { emitHistoricalEvents, emitRuntimeTailEvents, emitSessionHeadAdvanced, emitTranscriptPrepended, emitTranscriptReplacement, latestCompletedHistoricalHead, } from "./events.js";
 import { commandSessionMetadata, encryptedSessionMetadata, sessionFallbackFromCommand } from "./metadata.js";
 const historicalBackfillEventLimit = 200;
 export async function handleCreateSession(ws, config, command) {
@@ -15,6 +15,8 @@ export async function handleCreateSession(ws, config, command) {
     const cwd = command.cwd || process.cwd();
     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,
@@ -22,6 +24,7 @@ export async function handleCreateSession(ws, config, command) {
             mode: "persistent",
             cwd,
             permissionMode: metadata?.permissionMode,
+            model,
         });
         let providerName;
         const requestedRuntimeName = metadata?.requestedRuntimeName;
@@ -39,6 +42,8 @@ export async function handleCreateSession(ws, config, command) {
             agent: command.agent,
             cwd,
             name: providerName ?? command.name,
+            ...(model ? { model } : {}),
+            ...(tags.length > 0 ? { tags } : {}),
             handle,
         };
         sessions.set(command.sessionId, state);
@@ -53,6 +58,7 @@ export async function handleCreateSession(ws, config, command) {
                 agent: command.agent,
                 cwd,
                 name: state.name,
+                model,
                 requestedRuntimeName: requestedRuntimeName ? true : undefined,
                 runtime: {
                     acpxRecordId: handle.acpxRecordId,
@@ -66,6 +72,7 @@ export async function handleCreateSession(ws, config, command) {
             requestId: command.requestId,
             sessionId: command.sessionId,
             ...(providerName ? { name: providerName } : {}),
+            ...runtimeIdentityProjection(state),
             encryptedMetadata: await encryptedSessionMetadata(config, command.sessionId, state, {
                 emptyRuntimeSession: true,
                 ...(providerName ? { providerName, renamedAt: new Date().toISOString() } : {}),
@@ -78,6 +85,9 @@ export async function handleCreateSession(ws, config, command) {
         await sendCommandResponse(ws, createSessionFailureResponse(command, error));
     }
 }
+function modelFromCommand(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
 export async function handleImportHistoricalSession(ws, config, command) {
     if (command.type !== "machine:importHistoricalSession")
         return;
@@ -92,6 +102,7 @@ export async function handleImportHistoricalSession(ws, config, command) {
             resumeSessionId: command.runtimeSessionId,
             cwd,
         });
+        assertImportedRuntimeHandleMatches(command.runtimeSessionId, handle);
         const state = {
             sessionId: command.sessionId,
             agent: command.agent,
@@ -136,6 +147,7 @@ export async function handleImportHistoricalSession(ws, config, command) {
             type: "machine:sessionReady",
             requestId: command.requestId,
             sessionId: command.sessionId,
+            ...runtimeIdentityProjection(backfilledState, command.runtimeSessionId),
             encryptedMetadata: await encryptedSessionMetadata(config, command.sessionId, backfilledState, {
                 ...importedMetadataBase,
                 ...historicalBackfillMetadata(backfill),
@@ -246,12 +258,19 @@ function historicalSessionPage(value) {
         return { sessions: value };
     return value;
 }
-export async function resumeSession(ws, config, sessionId, requestId, fallback, announceSuccess = true) {
+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);
+        const backfill = await backfillHistoricalEvents(ws, config, refreshed, undefined, refreshed.historicalBackfill ?? fallback?.historicalBackfill, {
+            direction: syncDirection,
+        });
         const resumed = withHistoricalBackfill(refreshed, backfill);
         sessions.set(sessionId, resumed);
         await appendAudit({
@@ -274,6 +293,7 @@ export async function resumeSession(ws, config, sessionId, requestId, fallback,
                 requestId,
                 sessionId,
                 ...(nameChanged ? { name: resumed.name } : {}),
+                ...runtimeIdentityProjection(resumed),
                 encryptedMetadata: await encryptedSessionMetadata(config, sessionId, resumed, {
                     resumedAt: new Date().toISOString(),
                     ...historicalBackfillMetadata(backfill),
@@ -298,10 +318,19 @@ 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);
+        const backfill = await backfillHistoricalEvents(ws, config, state, resumeSessionId, fallback?.historicalBackfill, {
+            direction: syncDirection,
+        });
         const resumed = withHistoricalBackfill(state, backfill);
         sessions.set(sessionId, resumed);
         await appendAudit({
@@ -324,6 +353,7 @@ export async function resumeSession(ws, config, sessionId, requestId, fallback,
                 requestId,
                 sessionId,
                 ...(nameChanged ? { name: resumed.name } : {}),
+                ...runtimeIdentityProjection(resumed, resumeSessionId),
                 encryptedMetadata: await encryptedSessionMetadata(config, sessionId, resumed, {
                     resumedAt: new Date().toISOString(),
                     ...historicalBackfillMetadata(backfill),
@@ -421,6 +451,49 @@ function runtimeHandleFromFallback(sessionId, agent, cwd, fallback) {
         externalHandle: runtime.externalHandle,
     };
 }
+function assertImportedRuntimeHandleMatches(runtimeSessionId, handle) {
+    const ids = runtimeHandleSessionIds(handle);
+    if (ids.has(runtimeSessionId))
+        return;
+    const actual = [...ids].join(", ") || "none";
+    throw new Error(`Runtime import returned a different session handle: requested ${runtimeSessionId}, got ${actual}`);
+}
+function runtimeHandleSessionIds(handle) {
+    const ids = new Set();
+    addRuntimeHandleSessionId(ids, handle.acpxRecordId);
+    addRuntimeHandleSessionId(ids, handle.backendSessionId);
+    addRuntimeHandleSessionId(ids, handle.agentSessionId);
+    addRuntimeHandleSessionId(ids, handle.externalHandle?.sessionId);
+    return ids;
+}
+function addRuntimeHandleSessionId(ids, value) {
+    if (typeof value === "string" && value.trim().length > 0)
+        ids.add(value);
+}
+function runtimeIdentityProjection(session, explicitRuntimeSessionId) {
+    const ids = runtimeSessionIdsForState(session, explicitRuntimeSessionId);
+    return {
+        ...(ids[0] ? { runtimeSessionId: ids[0] } : {}),
+        ...(ids.length > 0 ? { runtimeSessionIds: ids } : {}),
+    };
+}
+function runtimeSessionIdsForState(session, explicitRuntimeSessionId) {
+    const ids = new Set();
+    addRuntimeSessionId(ids, explicitRuntimeSessionId);
+    addRuntimeSessionId(ids, session.handle.backendSessionId);
+    addRuntimeSessionId(ids, session.handle.agentSessionId);
+    addRuntimeSessionId(ids, session.handle.acpxRecordId);
+    addRuntimeSessionId(ids, session.handle.externalHandle?.sessionId);
+    return [...ids];
+}
+function addRuntimeSessionId(ids, value) {
+    if (typeof value !== "string")
+        return;
+    const id = value.trim();
+    if (!id || id.startsWith("event:"))
+        return;
+    ids.add(id);
+}
 export function usesAuthoritativeTranscript(session) {
     const runtime = getRuntime(session.cwd);
     const listAgents = "listAgents" in runtime && typeof runtime.listAgents === "function" ? runtime.listAgents : undefined;
@@ -441,8 +514,10 @@ export async function replaceAuthoritativeTranscript(ws, config, session, runtim
     }
     const result = authoritativeBackfillResult(page);
     await emitTranscriptReplacement(ws, config, session.sessionId, page.events, {
+        requestId: input.requestId,
         currentHead: input.currentHead ?? page.currentHead,
         lastTurnId: input.lastTurnId ?? page.lastTurnId,
+        replacementKind: input.replacementKind,
         status: input.status,
         hasMoreBefore: page.hasMoreBefore,
         nextBefore: page.nextBefore,
@@ -527,7 +602,7 @@ async function backfillHistoricalEvents(ws, config, session, runtimeSessionId =
     if (!runtimeSessionId)
         return completedBackfillResult(0);
     if (usesAuthoritativeTranscript(session)) {
-        if (previousBackfill?.status === "partial" && previousBackfill.providerCursor) {
+        if ((options.direction ?? "auto") === "older" && previousBackfill?.status === "partial" && previousBackfill.providerCursor) {
             return await prependAuthoritativeTranscript(ws, config, session, runtimeSessionId, previousBackfill, { strict: options.strict });
         }
         return await replaceAuthoritativeTranscript(ws, config, session, runtimeSessionId, { strict: options.strict });
@@ -549,26 +624,58 @@ async function backfillHistoricalEvents(ws, config, session, runtimeSessionId =
             throw error;
         historicalEvents = [];
     }
-    const tailWindow = historicalTailWindowByTurn(historicalEvents, previousBackfill?.totalEvents);
+    const direction = options.direction ?? "auto";
+    const plan = planAppendOnlyHistoricalBackfill(historicalEvents, previousBackfill, direction);
+    const tailWindow = plan.tailWindow;
     if (tailWindow.events.length > 0) {
         await emitRuntimeTailEvents(ws, config, session.sessionId, tailWindow.events, tailWindow.startIndex);
     }
-    const cursor = normalizedBackfillCursor(previousBackfill, historicalEvents.length);
-    const olderWindow = historicalEventsWindowByTurn(historicalEvents, cursor, historicalBackfillEventLimit);
+    const olderWindow = plan.olderWindow;
     if (olderWindow.events.length > 0) {
         await emitHistoricalEvents(ws, config, session.sessionId, olderWindow.events, olderWindow.startIndex);
     }
-    const status = olderWindow.nextCursor > 0 ? "partial" : "completed";
-    return {
+    const computedHead = direction === "older" && previousBackfill
+        ? previousBackfill.head
+        : latestCompletedHistoricalHead(session.sessionId, historicalEvents, {
+            ...(previousBackfill?.totalEvents !== undefined && previousBackfill.head === undefined
+                ? { preferTailBasisForExistingEvents: true }
+                : {}),
+            ...(previousBackfill?.totalEvents !== undefined ? { previousTotalEvents: previousBackfill.totalEvents } : {}),
+            ...(tailWindow.events.length > 0 ? { tailStartIndex: tailWindow.startIndex } : {}),
+        });
+    const head = direction === "older" && previousBackfill
+        ? previousBackfill.head
+        : preferPersistedHistoricalHeadBasis(computedHead, previousBackfill?.head);
+    const result = {
         emittedEvents: tailWindow.events.length + olderWindow.events.length,
         availableEvents: historicalEvents.length,
-        cursor: olderWindow.nextCursor,
+        cursor: plan.cursor,
         olderBackfilledEvents: olderWindow.events.length,
-        status,
+        status: plan.status,
         tailRepairedEvents: tailWindow.events.length,
         totalEvents: historicalEvents.length,
-        truncated: status === "partial",
+        truncated: plan.truncated,
+        ...(head ? { head } : {}),
     };
+    if (head) {
+        const backfilledSession = withHistoricalBackfill(session, result);
+        await emitSessionHeadAdvanced(ws, session.sessionId, head, await encryptedSessionMetadata(config, session.sessionId, backfilledSession, {
+            ...historicalBackfillMetadata(result),
+            historicalBackfilledAt: new Date().toISOString(),
+        }), "completed");
+    }
+    return result;
+}
+function preferPersistedHistoricalHeadBasis(computed, persisted) {
+    if (!computed || !persisted)
+        return computed;
+    if (computed.currentHead === persisted.currentHead &&
+        computed.lastTurnId === persisted.lastTurnId &&
+        computed.basis.turnId === persisted.basis.turnId &&
+        computed.basis.turnSeq === persisted.basis.turnSeq) {
+        return persisted;
+    }
+    return computed;
 }
 function completedBackfillResult(totalEvents) {
     return {
@@ -589,6 +696,23 @@ function normalizedBackfillCursor(previousBackfill, totalEvents) {
         return 0;
     return Math.max(0, Math.min(previousBackfill.cursor, totalEvents));
 }
+export function planAppendOnlyHistoricalBackfill(historicalEvents, previousBackfill, direction = "auto", maxEvents = historicalBackfillEventLimit) {
+    const tailWindow = direction === "latest" || direction === "auto"
+        ? historicalTailWindowByTurn(historicalEvents, previousBackfill?.totalEvents)
+        : { events: [], startIndex: historicalEvents.length };
+    const cursor = normalizedBackfillCursor(previousBackfill, historicalEvents.length);
+    const olderWindow = direction === "older" || direction === "auto" || previousBackfill === undefined
+        ? historicalEventsWindowByTurn(historicalEvents, cursor, maxEvents)
+        : { events: [], nextCursor: cursor, startIndex: cursor };
+    const status = olderWindow.nextCursor > 0 ? "partial" : "completed";
+    return {
+        cursor: olderWindow.nextCursor,
+        olderWindow,
+        status,
+        tailWindow,
+        truncated: status === "partial",
+    };
+}
 function historicalTailWindowByTurn(events, previousTotalEvents) {
     if (previousTotalEvents === undefined || events.length <= previousTotalEvents) {
         return { events: [], startIndex: events.length };
@@ -645,6 +769,7 @@ function withHistoricalBackfill(session, backfill) {
         ...session,
         historicalBackfill: {
             cursor: backfill.cursor,
+            ...(backfill.head ? { head: backfill.head } : {}),
             providerCursor: backfill.providerCursor,
             status: backfill.status,
             totalEvents: backfill.totalEvents,
@@ -661,6 +786,8 @@ function historicalBackfillMetadata(backfill) {
         backfilledEvents: backfill.emittedEvents,
         historicalOlderBackfilledEvents: backfill.olderBackfilledEvents,
         historicalTailRepairedEvents: backfill.tailRepairedEvents,
+        historicalHead: backfill.head,
+        runtimeCurrentEventCount: backfill.totalEvents,
         availableHistoricalEvents: backfill.availableEvents,
         truncatedHistoricalBackfill: backfill.truncated,
     };
@@ -670,7 +797,7 @@ export async function handleResume(ws, config, command) {
         return;
     if (!claimCommandRequest(ws, command.requestId))
         return;
-    await resumeSession(ws, config, command.sessionId, command.requestId, await sessionFallbackFromCommand(config, command));
+    await resumeSession(ws, config, command.sessionId, command.requestId, await sessionFallbackFromCommand(config, command), true, command.syncDirection ?? "auto");
 }
 export async function handleClose(ws, config, command) {
     if (command.type !== "machine:close")
@@ -679,11 +806,22 @@ export async function handleClose(ws, config, command) {
         return;
     const session = sessions.get(command.sessionId);
     const fallback = session ? undefined : await sessionFallbackFromCommand(config, command);
+    const fallbackHandle = fallback ? runtimeHandleFromFallback(command.sessionId, fallback.agent, fallback.cwd, fallback) : undefined;
+    const sessionForClose = session ?? (fallback && fallbackHandle
+        ? {
+            sessionId: command.sessionId,
+            agent: fallback.agent,
+            cwd: fallback.cwd,
+            name: fallback.name,
+            handle: fallbackHandle,
+            historicalBackfill: fallback.historicalBackfill,
+        }
+        : undefined);
     let runtimeCloseError;
-    if (session) {
+    if (sessionForClose) {
         try {
-            await getRuntime(session.cwd).close({
-                handle: session.handle,
+            await getRuntime(sessionForClose.cwd).close({
+                handle: sessionForClose.handle,
                 reason: command.reason ?? "closed by controller",
             });
         }
@@ -702,8 +840,9 @@ export async function handleClose(ws, config, command) {
             requestId: command.requestId,
             reason: command.reason,
             loaded: Boolean(session),
-            agent: session?.agent ?? fallback?.agent,
-            cwd: session?.cwd ?? fallback?.cwd,
+            ...(!session && fallbackHandle ? { runtimeHandleFallback: true } : {}),
+            agent: sessionForClose?.agent ?? fallback?.agent,
+            cwd: sessionForClose?.cwd ?? fallback?.cwd,
             runtimeCloseError,
         },
     });

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

@@ -1,6 +1,6 @@
-import { type EncryptedEnvelope, type MachineCommand } from "@happy-elves/shared";
+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">, 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,9 +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,
@@ -32,10 +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,
@@ -45,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);
@@ -52,6 +65,7 @@ function historicalBackfillStateFromMetadata(metadata) {
     if (status && totalEvents !== undefined && cursor !== undefined) {
         return {
             cursor: Math.min(cursor, totalEvents),
+            ...(historicalHeadStateFromMetadata(metadata) ? { head: historicalHeadStateFromMetadata(metadata) } : {}),
             ...(typeof metadata.historicalBackfillProviderCursor === "string" ? { providerCursor: metadata.historicalBackfillProviderCursor } : {}),
             status,
             totalEvents,
@@ -60,6 +74,7 @@ function historicalBackfillStateFromMetadata(metadata) {
     if (status === "completed") {
         return {
             cursor: 0,
+            ...(historicalHeadStateFromMetadata(metadata) ? { head: historicalHeadStateFromMetadata(metadata) } : {}),
             ...(typeof metadata.historicalBackfillProviderCursor === "string" ? { providerCursor: metadata.historicalBackfillProviderCursor } : {}),
             status: "completed",
             totalEvents: totalEvents ?? 0,
@@ -70,6 +85,7 @@ function historicalBackfillStateFromMetadata(metadata) {
         if (totalEvents !== undefined && backfilledEvents !== undefined) {
             return {
                 cursor: Math.max(0, totalEvents - backfilledEvents),
+                ...(historicalHeadStateFromMetadata(metadata) ? { head: historicalHeadStateFromMetadata(metadata) } : {}),
                 ...(typeof metadata.historicalBackfillProviderCursor === "string" ? { providerCursor: metadata.historicalBackfillProviderCursor } : {}),
                 status: "partial",
                 totalEvents,
@@ -78,6 +94,31 @@ function historicalBackfillStateFromMetadata(metadata) {
     }
     return undefined;
 }
+function historicalHeadStateFromMetadata(metadata) {
+    const head = metadata.historicalHead;
+    if (!head || typeof head !== "object")
+        return undefined;
+    const basis = head.basis;
+    if (typeof head.currentHead !== "string" ||
+        typeof head.lastTurnId !== "string" ||
+        !basis ||
+        typeof basis !== "object" ||
+        typeof basis.turnId !== "string" ||
+        typeof basis.eventMessageId !== "string" ||
+        !Number.isInteger(basis.turnSeq)) {
+        return undefined;
+    }
+    return {
+        currentHead: head.currentHead,
+        lastTurnId: head.lastTurnId,
+        basis: {
+            turnId: basis.turnId,
+            eventMessageId: basis.eventMessageId,
+            turnSeq: basis.turnSeq,
+            ...(typeof basis.occurredAt === "number" ? { occurredAt: basis.occurredAt } : {}),
+        },
+    };
+}
 function historicalBackfillStatus(value) {
     return value === "partial" || value === "completed" ? value : undefined;
 }

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

@@ -1,4 +1,4 @@
-import { type MachineCommand } from "@happy-elves/shared";
+import { type MachineCommand } from "../../../../packages/shared/dist/index.js";
 import type { DaemonConfig } from "../types.js";
 export declare function handleRewind(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
 export declare function handleFork(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;

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);
@@ -113,7 +114,11 @@ export async function handleRewind(ws, config, command) {
     });
     if (usesAuthoritativeTranscript(nextSession)) {
         try {
-            const backfill = await replaceAuthoritativeTranscript(ws, config, nextSession, undefined, head);
+            const backfill = await replaceAuthoritativeTranscript(ws, config, nextSession, undefined, {
+                ...head,
+                replacementKind: "command",
+                requestId: command.requestId,
+            });
             sessions.set(command.sessionId, {
                 ...nextSession,
                 historicalBackfill: {
@@ -218,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,
@@ -241,6 +248,7 @@ export async function handleFork(ws, config, command) {
             ...primitiveRuntimeEvidence(source.handle, forkState.handle),
         },
     });
+    const authoritativeForkTranscript = usesAuthoritativeTranscript(forkState);
     await sendCommandResponse(ws, {
         type: "machine:sessionForked",
         requestId: command.requestId,
@@ -248,6 +256,7 @@ export async function handleFork(ws, config, command) {
         sourceCheckpointId,
         sessionId: command.targetSessionId,
         name: command.name,
+        ...(authoritativeForkTranscript ? { transcriptPending: true } : {}),
         encryptedMetadata: await encryptedSessionMetadata(config, command.targetSessionId, forkState, {
             forkedAt: new Date().toISOString(),
             importedFromRuntimeSessionId: sourceMetadata?.importedFromRuntimeSessionId,
@@ -256,10 +265,15 @@ export async function handleFork(ws, config, command) {
             sourceCheckpointId,
         }),
     });
-    if (usesAuthoritativeTranscript(forkState)) {
+    if (authoritativeForkTranscript) {
         try {
             const targetHead = primitiveResultHead(result);
-            const backfill = await replaceAuthoritativeTranscript(ws, config, forkState, undefined, targetHead);
+            const backfill = await replaceAuthoritativeTranscript(ws, config, forkState, undefined, {
+                ...targetHead,
+                replacementKind: "command",
+                requestId: command.requestId,
+                status: "completed",
+            });
             sessions.set(command.targetSessionId, {
                 ...forkState,
                 historicalBackfill: {
@@ -279,6 +293,14 @@ export async function handleFork(ws, config, command) {
                 summary: `Failed to refresh fork target transcript ${command.targetSessionId}`,
                 evidence: { requestId: command.requestId, sourceSessionId: command.sessionId, error: error instanceof Error ? error.message : String(error) },
             });
+            await sendCommandResponse(ws, {
+                type: "machine:error",
+                requestId: command.requestId,
+                sessionId: command.targetSessionId,
+                code: "SESSION_TRANSCRIPT_REPLACE_FAILED",
+                capability: "session.history",
+                message: error instanceof Error ? error.message : String(error),
+            });
         }
     }
 }
@@ -304,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);
@@ -370,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.d.ts

@@ -1,4 +1,31 @@
-import { type MachineCommand } from "@happy-elves/shared";
+import { type MachineCommand } from "../../../../packages/shared/dist/index.js";
 import type { DaemonConfig } from "../types.js";
+type PromptCommand = Extract<MachineCommand, {
+    type: "machine:prompt";
+}>;
+type PromptExecutionPhase = "decrypt-prompt" | "prepare-attachments" | "decrypt-memory-options" | "prepare-memory-context" | "emit-submitted" | "emit-memory-status" | "start-turn" | "attach-turn" | "audit-turn-start" | "stream-turn" | "await-turn-result" | "write-memory" | "refresh-runtime-metadata" | "emit-terminal" | "refresh-authoritative-transcript" | "send-turn-done" | "terminal-hooks";
 export declare function handlePrompt(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
+export declare function handleOptionResponse(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
+export declare function promptFailureResponse(command: PromptCommand, phase: PromptExecutionPhase, error: unknown): {
+    type: "machine:error";
+    requestId: string;
+    sessionId: string;
+    code: string;
+    message: string;
+};
+export declare function promptFailureAuditEvent(config: Pick<DaemonConfig, "machineId">, command: PromptCommand, phase: PromptExecutionPhase, error: unknown): {
+    sessionId: string;
+    machineId: string;
+    actor: "system";
+    action: string;
+    summary: string;
+    evidence: {
+        requestId: string;
+        turnId: string;
+        code: string;
+        phase: PromptExecutionPhase;
+        message: string;
+    };
+};
 export declare function handleCancel(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
+export {};