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

package/packages/client/dist/parsers.js

@@ -25,13 +25,17 @@ export function parseDevicesResponse(value) {
             }
             const machineId = device.machineId;
             const revokedAt = device.revokedAt;
+            const online = device.online;
+            const lastSeen = device.lastSeen;
             return {
                 deviceId: readStringField(device, "deviceId", "Device"),
                 name: readStringField(device, "name", "Device"),
                 kind,
                 current: readBooleanField(device, "current", "Device"),
                 revoked: readBooleanField(device, "revoked", "Device"),
+                ...(typeof online === "boolean" ? { online } : {}),
                 createdAt: readNumberField(device, "createdAt", "Device"),
+                ...(typeof lastSeen === "number" ? { lastSeen } : {}),
                 ...(typeof machineId === "string" ? { machineId } : {}),
                 ...(typeof revokedAt === "number" ? { revokedAt } : {}),
             };
@@ -90,6 +94,150 @@ export function parseRevokeDeviceResult(value) {
         revokedAt: readNumberField(record, "revokedAt", "Device revoke"),
     };
 }
+export function parseRenameDeviceResult(value) {
+    const record = assertRecord(value, "Device rename");
+    return {
+        deviceId: readStringField(record, "deviceId", "Device rename"),
+        name: readStringField(record, "name", "Device rename"),
+        renamedAt: readNumberField(record, "renamedAt", "Device rename"),
+    };
+}
+function optionalString(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+function optionalNumber(record, key) {
+    const value = record[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function parseWorkspaceSessionStar(value) {
+    const record = assertRecord(value, "Workspace star");
+    return {
+        sessionId: readStringField(record, "sessionId", "Workspace star"),
+        starredAt: readNumberField(record, "starredAt", "Workspace star"),
+    };
+}
+function parseWorkspaceRecentSession(value) {
+    const record = assertRecord(value, "Workspace recent session");
+    return {
+        sessionId: readStringField(record, "sessionId", "Workspace recent session"),
+        lastSelectedAt: readNumberField(record, "lastSelectedAt", "Workspace recent session"),
+    };
+}
+function parseWorkspaceCwdPin(value) {
+    const record = assertRecord(value, "Workspace cwd pin");
+    return {
+        machineId: readStringField(record, "machineId", "Workspace cwd pin"),
+        cwd: readStringField(record, "cwd", "Workspace cwd pin"),
+        ...(optionalString(record, "label") ? { label: optionalString(record, "label") } : {}),
+        pinnedAt: readNumberField(record, "pinnedAt", "Workspace cwd pin"),
+    };
+}
+function parseWorkspaceProjectPreference(value) {
+    const record = assertRecord(value, "Workspace project preference");
+    return {
+        projectKey: readStringField(record, "projectKey", "Workspace project preference"),
+        ...(optionalString(record, "machineId") ? { machineId: optionalString(record, "machineId") } : {}),
+        ...(optionalString(record, "cwd") ? { cwd: optionalString(record, "cwd") } : {}),
+        ...(optionalString(record, "agent") ? { agent: optionalString(record, "agent") } : {}),
+        ...(isMemoryMode(record.memoryMode) ? { memoryMode: record.memoryMode } : {}),
+        updatedAt: readNumberField(record, "updatedAt", "Workspace project preference"),
+    };
+}
+function isMemoryMode(value) {
+    return value === "off" || value === "readonly" || value === "readwrite";
+}
+export function parseWorkspaceSyncState(value) {
+    const record = assertRecord(value, "Workspace sync");
+    if (!Array.isArray(record.stars) ||
+        !Array.isArray(record.recentSessions) ||
+        !Array.isArray(record.cwdPins) ||
+        !Array.isArray(record.projectPreferences)) {
+        throw new ControllerClientError("Workspace sync response is invalid", "RELAY_RESPONSE_INVALID");
+    }
+    return {
+        stars: record.stars.map(parseWorkspaceSessionStar),
+        recentSessions: record.recentSessions.map(parseWorkspaceRecentSession),
+        cwdPins: record.cwdPins.map(parseWorkspaceCwdPin),
+        projectPreferences: record.projectPreferences.map(parseWorkspaceProjectPreference),
+    };
+}
+export function parseWorkspaceSessionStarResult(value) {
+    const record = assertRecord(value, "Workspace session star");
+    const starredAt = optionalNumber(record, "starredAt");
+    const unstarredAt = optionalNumber(record, "unstarredAt");
+    return {
+        sessionId: readStringField(record, "sessionId", "Workspace session star"),
+        starred: readBooleanField(record, "starred", "Workspace session star"),
+        ...(starredAt === undefined ? {} : { starredAt }),
+        ...(unstarredAt === undefined ? {} : { unstarredAt }),
+    };
+}
+export function parseWorkspaceRecentSessionResult(value) {
+    return parseWorkspaceRecentSession(value);
+}
+export function parseWorkspaceCwdPinResult(value) {
+    return parseWorkspaceCwdPin(value);
+}
+export function parseWorkspaceCwdUnpinResult(value) {
+    const record = assertRecord(value, "Workspace cwd unpin");
+    return {
+        machineId: readStringField(record, "machineId", "Workspace cwd unpin"),
+        cwd: readStringField(record, "cwd", "Workspace cwd unpin"),
+        removed: readBooleanField(record, "removed", "Workspace cwd unpin"),
+        removedAt: readNumberField(record, "removedAt", "Workspace cwd unpin"),
+    };
+}
+export function parseWorkspaceProjectPreferenceResult(value) {
+    return parseWorkspaceProjectPreference(value);
+}
+function parseEncryptedMemoryRecord(value) {
+    const record = assertRecord(value, "Memory");
+    return {
+        id: readStringField(record, "id", "Memory"),
+        projectKey: readStringField(record, "projectKey", "Memory"),
+        encryptedMemory: encryptedEnvelopeSchema.parse(record.encryptedMemory),
+        createdAt: readNumberField(record, "createdAt", "Memory"),
+        updatedAt: readNumberField(record, "updatedAt", "Memory"),
+    };
+}
+export function parseMemoryListResponse(value) {
+    const record = assertRecord(value, "Memory list");
+    if (!Array.isArray(record.memories)) {
+        throw new ControllerClientError("Memory list response is invalid", "RELAY_RESPONSE_INVALID");
+    }
+    return { memories: record.memories.map(parseEncryptedMemoryRecord) };
+}
+export function parseMemorySaveResult(value) {
+    return parseEncryptedMemoryRecord(value);
+}
+export function parseMemoryDeleteResult(value) {
+    const record = assertRecord(value, "Memory delete");
+    return {
+        id: readStringField(record, "id", "Memory delete"),
+        deleted: readBooleanField(record, "deleted", "Memory delete"),
+        deletedAt: readNumberField(record, "deletedAt", "Memory delete"),
+    };
+}
+function parseMemorySettings(value) {
+    const record = assertRecord(value, "Memory settings");
+    return {
+        projectKey: readStringField(record, "projectKey", "Memory settings"),
+        disabled: readBooleanField(record, "disabled", "Memory settings"),
+        injectionEnabled: readBooleanField(record, "injectionEnabled", "Memory settings"),
+        updatedAt: readNumberField(record, "updatedAt", "Memory settings"),
+    };
+}
+export function parseMemorySettingsList(value) {
+    const record = assertRecord(value, "Memory settings list");
+    if (!Array.isArray(record.settings)) {
+        throw new ControllerClientError("Memory settings list response is invalid", "RELAY_RESPONSE_INVALID");
+    }
+    return { settings: record.settings.map(parseMemorySettings) };
+}
+export function parseMemorySettingsResult(value) {
+    return parseMemorySettings(value);
+}
 function parseScope(value, label) {
     const record = assertRecord(value ?? {}, label);
     const machines = readOptionalStringArray(record, "machines", label);
@@ -175,4 +323,23 @@ export function parseSessionEventsResponse(value) {
         ...(oldestEventId === undefined ? {} : { oldestEventId }),
     };
 }
+export function parseRepairSessionHeadResult(value) {
+    const record = assertRecord(value, "Session head repair");
+    const session = assertRecord(record.session, "Session head repair session");
+    const basis = assertRecord(record.basis, "Session head repair basis");
+    const messageId = basis.messageId;
+    const reason = record.reason;
+    return {
+        advanced: readBooleanField(record, "advanced", "Session head repair"),
+        ...(typeof record.settled === "boolean" ? { settled: record.settled } : {}),
+        session: session,
+        basis: {
+            eventId: readNumberField(basis, "eventId", "Session head repair basis"),
+            ...(typeof messageId === "string" ? { messageId } : {}),
+            logicalTime: readNumberField(basis, "logicalTime", "Session head repair basis"),
+            turnSeq: readNumberField(basis, "turnSeq", "Session head repair basis"),
+        },
+        ...(typeof reason === "string" ? { reason } : {}),
+    };
+}
 //# sourceMappingURL=parsers.js.map

package/packages/client/dist/transport.d.ts

@@ -1,4 +1,4 @@
-import { type ControllerClientMessage, type EncryptedSessionEvent, type ServerMessage } from "@happy-elves/shared";
+import { type ControllerClientMessage, type EncryptedSessionEvent, type ServerMessage } from "../../shared/dist/index.js";
 import type { CommandResult, ControllerClientConfig, ControllerSubscriptionHandlers, DecodedSessionEvent } from "./types.js";
 export declare function subscribe(config: ControllerClientConfig, handlers: ControllerSubscriptionHandlers): WebSocket;
 type CommandTransport = {
@@ -37,5 +37,25 @@ export declare function sendAndWaitForMachineDevExecResult(config: ControllerCli
 }>, waitTimeoutMs?: number): Promise<Extract<ServerMessage, {
     type: "server:machineDevExecResult";
 }>>;
+export declare function sendAndWaitForGatewayResult(config: ControllerClientConfig, command: Extract<ControllerClientMessage, {
+    type: "controller:gateway";
+}>): Promise<Extract<ServerMessage, {
+    type: "server:gatewayResult";
+}>>;
+export declare function sendAndWaitForScheduleResult(config: ControllerClientConfig, command: Extract<ControllerClientMessage, {
+    type: "controller:schedule";
+}>): Promise<Extract<ServerMessage, {
+    type: "server:scheduleResult";
+}>>;
+export declare function sendAndWaitForMemoryResult(config: ControllerClientConfig, command: Extract<ControllerClientMessage, {
+    type: "controller:memory";
+}>): Promise<Extract<ServerMessage, {
+    type: "server:memoryResult";
+}>>;
+export declare function sendAndWaitForTurnReconcileResult(config: ControllerClientConfig, command: Extract<ControllerClientMessage, {
+    type: "controller:reconcileTurn";
+}>): Promise<Extract<ServerMessage, {
+    type: "server:turnReconciled";
+}>>;
 export {};
 //# sourceMappingURL=transport.d.ts.map

package/packages/client/dist/transport.js

@@ -60,10 +60,26 @@ export function subscribe(config, handlers) {
             void handlers.onSessionTranscriptPrepended?.(message);
             return;
         }
+        if (message.type === "server:memoryResult") {
+            void handlers.onMemoryResult?.(message);
+            return;
+        }
+        if (message.type === "server:turnReconciled") {
+            void handlers.onTurnReconciled?.(message);
+            return;
+        }
         if (message.type === "server:historicalSessions") {
             handlers.onHistoricalSessions?.(message);
             return;
         }
+        if (message.type === "server:gatewayResult") {
+            handlers.onGatewayResult?.(message);
+            return;
+        }
+        if (message.type === "server:scheduleResult") {
+            handlers.onScheduleResult?.(message);
+            return;
+        }
         if (message.type === "server:ack") {
             handlers.onAck?.(message);
             return;
@@ -85,11 +101,14 @@ export async function sendCommand(context, command, waitForDone = false, timeout
     const targetTurnId = "turnId" in command ? command.turnId : undefined;
     return await new Promise((resolve, reject) => {
         let settled = false;
+        let retainedPoller;
         const finish = (result) => {
             if (settled)
                 return;
             settled = true;
             globalThis.clearTimeout(timer);
+            if (retainedPoller)
+                globalThis.clearInterval(retainedPoller);
             ws.close();
             resolve(result);
         };
@@ -98,10 +117,24 @@ export async function sendCommand(context, command, waitForDone = false, timeout
                 return;
             settled = true;
             globalThis.clearTimeout(timer);
+            if (retainedPoller)
+                globalThis.clearInterval(retainedPoller);
             ws.close();
             reject(error);
         };
-        const resolveFromRetainedTurnIfDone = (sessionId, turnId, sessionIdFromAck) => {
+        const commandResultFromAck = () => ({
+            requestId: command.requestId,
+            sessionId: ackedSessionId,
+            turnId: ackedTurnId,
+            admission: ackedAdmission,
+            dispatch: ackedDispatch,
+            events,
+        });
+        let retainedLookupInFlight = false;
+        const resolveFromRetainedTurnIfDone = (sessionId, turnId) => {
+            if (retainedLookupInFlight)
+                return;
+            retainedLookupInFlight = true;
             void context.sessionEvents(sessionId, { limit: 1000 })
                 .then(({ events: retainedEvents }) => retainedEvents.filter((event) => event.turnId === turnId))
                 .then(async (turnEvents) => {
@@ -116,9 +149,21 @@ export async function sendCommand(context, command, waitForDone = false, timeout
                         events.push(event);
                 }
                 events.sort((left, right) => left.id - right.id);
-                finish({ requestId: command.requestId, sessionId: sessionIdFromAck, events });
+                finish(commandResultFromAck());
             })
-                .catch(() => { });
+                .catch(() => { })
+                .finally(() => {
+                retainedLookupInFlight = false;
+            });
+        };
+        const startRetainedTurnPoller = (sessionId, turnId) => {
+            if (retainedPoller)
+                return;
+            resolveFromRetainedTurnIfDone(sessionId, turnId);
+            retainedPoller = globalThis.setInterval(() => {
+                if (!settled)
+                    resolveFromRetainedTurnIfDone(sessionId, turnId);
+            }, 2_000);
         };
         const timer = globalThis.setTimeout(() => {
             fail(new ControllerClientError("Timed out waiting for command result", "COMMAND_TIMEOUT", {
@@ -129,6 +174,9 @@ export async function sendCommand(context, command, waitForDone = false, timeout
             }));
         }, timeoutMs ?? (waitForDone ? 30 * 60 * 1000 : 15_000));
         let ackedSessionId;
+        let ackedTurnId;
+        let ackedAdmission;
+        let ackedDispatch;
         let commandAcked = false;
         ws.addEventListener("message", (event) => {
             if (settled)
@@ -148,11 +196,14 @@ export async function sendCommand(context, command, waitForDone = false, timeout
             if (message.type === "server:ack" && message.requestId === command.requestId) {
                 commandAcked = true;
                 ackedSessionId = message.sessionId;
+                ackedTurnId = message.turnId;
+                ackedAdmission = message.admission;
+                ackedDispatch = message.dispatch;
                 if (!waitForDone) {
-                    finish({ requestId: command.requestId, sessionId: ackedSessionId, events });
+                    finish(commandResultFromAck());
                 }
                 else if (targetSessionId && targetTurnId) {
-                    resolveFromRetainedTurnIfDone(targetSessionId, targetTurnId, ackedSessionId);
+                    startRetainedTurnPoller(targetSessionId, targetTurnId);
                 }
                 return;
             }
@@ -172,7 +223,7 @@ export async function sendCommand(context, command, waitForDone = false, timeout
                     void decryptJson(context.config.accountSecret, message.event.payload)
                         .then((payload) => {
                         if (payload.type === "done") {
-                            finish({ requestId: command.requestId, sessionId: ackedSessionId, events });
+                            finish(commandResultFromAck());
                         }
                     })
                         .catch(() => { });
@@ -197,6 +248,18 @@ export async function sendAndWaitForMachineDiagnostics(config, command) {
 export async function sendAndWaitForMachineDevExecResult(config, command, waitTimeoutMs) {
     return await sendAndWaitForServerMessage(config, command, "server:machineDevExecResult", "machine dev exec result; remote result is unknown", waitTimeoutMs ?? (command.timeoutMs ?? 60_000) + 15_000);
 }
+export async function sendAndWaitForGatewayResult(config, command) {
+    return await sendAndWaitForServerMessage(config, command, "server:gatewayResult", "gateway result", 30_000);
+}
+export async function sendAndWaitForScheduleResult(config, command) {
+    return await sendAndWaitForServerMessage(config, command, "server:scheduleResult", "schedule result", 30_000);
+}
+export async function sendAndWaitForMemoryResult(config, command) {
+    return await sendAndWaitForServerMessage(config, command, "server:memoryResult", "memory result", 30_000);
+}
+export async function sendAndWaitForTurnReconcileResult(config, command) {
+    return await sendAndWaitForServerMessage(config, command, "server:turnReconciled", "turn reconcile result", 45_000);
+}
 function connect(config) {
     return new Promise((resolve, reject) => {
         const ws = new WebSocket(wsUrl(config.relayUrl));

package/packages/client/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { DirectoryListing, EncryptedSessionEvent, FilePreviewMode, FilePreviewResult, HistoricalSessionSnapshot, MachineSnapshot, MachineDevExecResult, MachineDiagnostics, ServerMessage, SessionEventPayload, SessionSnapshot } from "@happy-elves/shared";
+import type { DirectoryListing, EncryptedSessionEvent, FilePreviewMode, FilePreviewResult, GatewayChannelInput, GatewayCommandResult, HistoricalSessionSnapshot, MachineSnapshot, MachineDevExecResult, MachineDiagnostics, ScheduleCommandResult, ScheduleCreateInput, MemoryCommandResult, MemoryMode, MemoryPromoteInput, MemoryWriteInput, ServerMessage, SessionEventPayload, SessionSnapshot, TurnReconcileResult } from "../../shared/dist/index.js";
 export type ControllerClientConfig = {
     relayUrl: string;
     controllerToken: string;
@@ -11,6 +11,9 @@ export type CommandResult = {
     requestId?: string;
     sessionId?: string;
     turnId?: string;
+    admission?: "accepted" | "replayed";
+    dispatch?: "queued" | "delivered";
+    mode?: "existing";
     events: EncryptedSessionEvent[];
 };
 export type DecodedSessionEvent = EncryptedSessionEvent & {
@@ -40,6 +43,18 @@ export type ControllerSubscriptionHandlers = {
     onHistoricalSessions?: (message: Extract<ServerMessage, {
         type: "server:historicalSessions";
     }>) => void;
+    onGatewayResult?: (message: Extract<ServerMessage, {
+        type: "server:gatewayResult";
+    }>) => void;
+    onScheduleResult?: (message: Extract<ServerMessage, {
+        type: "server:scheduleResult";
+    }>) => void;
+    onMemoryResult?: (message: Extract<ServerMessage, {
+        type: "server:memoryResult";
+    }>) => void;
+    onTurnReconciled?: (message: Extract<ServerMessage, {
+        type: "server:turnReconciled";
+    }>) => void;
     onAck?: (message: Extract<ServerMessage, {
         type: "server:ack";
     }>) => void;
@@ -58,7 +73,9 @@ export type ControllerDevice = {
     kind: "controller" | "machine";
     current: boolean;
     revoked: boolean;
+    online?: boolean;
     createdAt: number;
+    lastSeen?: number;
     machineId?: string;
     revokedAt?: number;
 };
@@ -69,6 +86,96 @@ export type AddControllerDeviceResult = {
     deviceName: string;
     createdAt: number;
 };
+export type RenameDeviceResult = {
+    deviceId: string;
+    name: string;
+    renamedAt: number;
+};
+export type WorkspaceSessionStar = {
+    sessionId: string;
+    starredAt: number;
+};
+export type WorkspaceRecentSession = {
+    sessionId: string;
+    lastSelectedAt: number;
+};
+export type WorkspaceCwdPin = {
+    machineId: string;
+    cwd: string;
+    label?: string;
+    pinnedAt: number;
+};
+export type WorkspaceProjectPreference = {
+    projectKey: string;
+    machineId?: string;
+    cwd?: string;
+    agent?: string;
+    memoryMode?: MemoryMode;
+    updatedAt: number;
+};
+export type WorkspaceSyncState = {
+    stars: WorkspaceSessionStar[];
+    recentSessions: WorkspaceRecentSession[];
+    cwdPins: WorkspaceCwdPin[];
+    projectPreferences: WorkspaceProjectPreference[];
+};
+export type WorkspaceSessionStarResult = {
+    sessionId: string;
+    starred: boolean;
+    starredAt?: number;
+    unstarredAt?: number;
+};
+export type WorkspaceCwdPinInput = {
+    machineId: string;
+    cwd: string;
+    label?: string;
+};
+export type WorkspaceProjectPreferenceInput = {
+    projectKey: string;
+    machineId?: string;
+    cwd?: string;
+    agent?: string;
+    memoryMode?: MemoryMode;
+};
+export type MemoryPayload = {
+    title?: string;
+    text: string;
+    tags?: string[];
+};
+export type EncryptedMemoryRecord = {
+    id: string;
+    projectKey: string;
+    encryptedMemory: import("../../shared/dist/index.js").EncryptedEnvelope;
+    createdAt: number;
+    updatedAt: number;
+};
+export type DecodedMemoryRecord = {
+    id: string;
+    projectKey: string;
+    title?: string;
+    text: string;
+    tags?: string[];
+    createdAt: number;
+    updatedAt: number;
+};
+export type MemorySettings = {
+    projectKey: string;
+    disabled: boolean;
+    injectionEnabled: boolean;
+    updatedAt: number;
+};
+export type MemorySaveInput = {
+    id?: string;
+    projectKey: string;
+    title?: string;
+    text: string;
+    tags?: string[];
+};
+export type MemorySearchInput = {
+    projectKey: string;
+    query: string;
+    limit?: number;
+};
 export type ControllerInviteCreateResult = {
     accountId: string;
     inviteCode: string;
@@ -121,6 +228,8 @@ export type SessionMetadata = {
     cwd?: string;
     agent?: string;
     permissionMode?: PermissionMode;
+    tags?: string[];
+    tagKeys?: string[];
     [key: string]: unknown;
 };
 export type SessionFilter = {
@@ -128,6 +237,7 @@ export type SessionFilter = {
     agent?: string;
     cwd?: string;
     name?: string;
+    tags?: string[];
 };
 export type CreateSessionInput = {
     machineId: string;
@@ -137,14 +247,26 @@ export type CreateSessionInput = {
     runtimeName?: string;
     createdFrom?: string;
     permissionMode?: PermissionMode;
+    model?: string;
+    tags?: string[];
+    hiddenFromWorkspace?: boolean;
+    source?: string;
 };
 export type RunOptions = {
     wait?: boolean;
     permissionMode?: PermissionMode;
+    memoryMode?: MemoryMode;
+    memoryProjectKey?: string;
+    memoryTopN?: number;
+    model?: string;
     waitTimeoutMs?: number;
     ackTimeoutMs?: number;
+    inactivityTimeoutMs?: number;
     runtimeTimeoutMs?: number;
 };
+export type TurnReconcileResponse = TurnReconcileResult & {
+    machineId: string;
+};
 export type HistoricalSessionsInput = {
     machineId: string;
     cwd?: string;
@@ -173,6 +295,36 @@ export type MachineDevExecInput = {
     timeoutMs?: number;
     waitTimeoutMs?: number;
 };
+export type GatewayCommandInput = {
+    machineId: string;
+    action: "list" | "get" | "upsert" | "enable" | "disable" | "test" | "notify";
+    channelId?: string;
+    channel?: GatewayChannelInput;
+    externalConversationId?: string;
+    externalMessageId?: string;
+    text?: string;
+};
+export type GatewayCommandResponse = GatewayCommandResult;
+export type ScheduleCommandInput = {
+    machineId: string;
+    action: "list" | "show" | "create" | "pause" | "resume" | "delete" | "history" | "run" | "runDue" | "runMissed";
+    scheduleId?: string;
+    occurrenceId?: string;
+    schedule?: ScheduleCreateInput;
+};
+export type ScheduleCommandResponse = ScheduleCommandResult;
+export type MemoryCommandInput = {
+    machineId: string;
+    action: "overview" | "read" | "search" | "reindex" | "write" | "promote" | "status" | "sync";
+    projectKey?: string;
+    path?: string;
+    query?: string;
+    limit?: number;
+    mode?: MemoryMode;
+    write?: MemoryWriteInput;
+    promote?: MemoryPromoteInput;
+};
+export type MemoryCommandResponse = MemoryCommandResult;
 export type ImportHistoricalSessionInput = {
     machineId: string;
     agent: string;
@@ -186,6 +338,7 @@ export type ImportHistoricalSessionInput = {
 export type ForkInput = {
     from: string;
     name: string;
+    tags?: string[];
 };
 export type CancelInput = {
     turnId?: string;
@@ -202,6 +355,29 @@ export type CollectInput = {
     since?: EventCursor;
     limit?: number;
 };
+export type RepairSessionHeadInput = {
+    currentHead: string;
+    lastTurnId: string;
+    status?: "completed" | "cancelled" | "failed";
+    basis: {
+        turnId: string;
+        eventMessageId: string;
+        turnSeq: number;
+        occurredAt?: number;
+    };
+};
+export type RepairSessionHeadResult = {
+    advanced: boolean;
+    settled?: boolean;
+    session: SessionSnapshot;
+    basis: {
+        eventId: number;
+        messageId?: string;
+        logicalTime: number;
+        turnSeq: number;
+    };
+    reason?: string;
+};
 export type ControllerInviteCreateInput = {
     deviceName?: string;
     ttlMs?: number;

package/packages/client/dist/validation.d.ts

@@ -1,4 +1,4 @@
-import type { SessionSnapshot } from "@happy-elves/shared";
+import type { SessionSnapshot } from "../../shared/dist/index.js";
 import type { EventCursor, WaitCondition } from "./types.js";
 export declare function assertRecord(value: unknown, label: string): Record<string, unknown>;
 export declare function readStringField(record: Record<string, unknown>, key: string, label: string): string;