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

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

@@ -1,4 +1,4 @@
-import type { SessionSnapshot } from "@happy-elves/shared";
+import type { SessionSnapshot } from "../../../packages/shared/dist/index.js";
 export type TokenKind = "controller" | "machine";
 export type ScopedTokenScope = {
     name?: string;
@@ -18,6 +18,7 @@ export type TokenRecord = {
     revoked_at: number | null;
     expires_at: number | null;
     scope: string | null;
+    last_seen: number | null;
     created_at: number;
 };
 export type MachineRow = {
@@ -41,6 +42,10 @@ export type SessionRow = {
     encrypted_metadata: string | null;
     current_head: string | null;
     last_turn_id: string | null;
+    head_basis_event_id: number | null;
+    head_basis_message_id: string | null;
+    head_basis_logical_time: number | null;
+    head_basis_turn_seq: number | null;
     source_session_id: string | null;
     source_checkpoint_id: string | null;
     created_at: number;
@@ -59,12 +64,77 @@ export type EventRow = {
     created_at: number;
     occurred_at: number | null;
 };
+export type PendingSessionHeadAdvanceRow = {
+    id: number;
+    account_id: string;
+    session_id: string;
+    machine_id: string;
+    message_id: string | null;
+    current_head: string;
+    last_turn_id: string;
+    basis_turn_id: string;
+    basis_event_message_id: string;
+    basis_turn_seq: number;
+    basis_occurred_at: number | null;
+    encrypted_metadata: string | null;
+    created_at: number;
+    updated_at: number;
+};
 export type CommandResultRow = {
     account_id: string;
     request_id: string;
     response: string;
     created_at: number;
 };
+export type RelayAdmissionRow = {
+    account_id: string;
+    request_id: string;
+    session_id: string;
+    machine_id: string;
+    kind: "createSession" | "prompt";
+    turn_id: string | null;
+    admission: "accepted";
+    dispatch: "queued" | "delivered";
+    started_at: number | null;
+    finished_at: number | null;
+    terminal_status: "completed" | "cancelled" | "failed" | "error" | "unknown" | null;
+    last_error_code: string | null;
+    created_at: number;
+    updated_at: number;
+};
+export type RelaySessionClaimRow = {
+    account_id: string;
+    session_id: string;
+    request_id: string;
+    machine_id: string;
+    turn_id: string;
+    command_type: "prompt";
+    state: "active";
+    created_at: number;
+    updated_at: number;
+};
+export type SessionRuntimeBindingRow = {
+    account_id: string;
+    machine_id: string;
+    agent: string;
+    runtime_session_id: string;
+    session_id: string;
+    status: "active" | "closed";
+    created_at: number;
+    updated_at: number;
+};
+export type RelayDispatchOutboxRow = {
+    account_id: string;
+    request_id: string;
+    machine_id: string;
+    session_id: string;
+    command_type: string;
+    message: string;
+    state: "queued" | "delivered";
+    created_at: number;
+    updated_at: number;
+    delivered_at: number | null;
+};
 export type PairingRow = {
     code: string;
     account_id: string;

package/apps/relay/dist/websocket.js

@@ -50,6 +50,7 @@ export function registerWebsocketRoute(app, context, originAllowed) {
                     fail("Machine token does not match machine id", "AUTH_TOKEN_INVALID");
                     return;
                 }
+                context.markTokenSeen(token.token);
                 if (message.clientType === "controller") {
                     const controller = {
                         id: connectionId,
@@ -84,6 +85,7 @@ export function registerWebsocketRoute(app, context, originAllowed) {
                     const machineSnapshotNow = context.updateMachineLastSeen(machine.accountId, machine.machineId);
                     if (machineSnapshotNow)
                         context.broadcastControllers(machine.accountId, { type: "server:machine", machine: machineSnapshotNow });
+                    context.deliverQueuedCommandsForMachine(machine);
                     context.resumeOfflineSessionsForMachine(machine);
                 }
                 return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.31",
+  "version": "0.1.0-beta.310",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {
@@ -10,24 +10,17 @@
     "LICENSE",
     "README.md",
     "apps/cli/dist",
+    "apps/cli/package.json",
     "apps/daemon/dist",
     "apps/daemon/package.json",
     "apps/relay/dist",
-    "apps/relay/package.json",
     "packages/shared/dist",
-    "packages/shared/package.json",
     "packages/client/dist",
-    "packages/client/package.json",
     "packages/runtime/dist",
-    "packages/runtime/package.json",
     "packages/runtime-acpx/dist",
-    "packages/runtime-acpx/package.json",
     "packages/runtime-cli/dist",
-    "packages/runtime-cli/package.json",
     "packages/agent-sdk/dist",
-    "packages/agent-sdk/package.json",
-    "packages/pie-provider/dist",
-    "packages/pie-provider/package.json"
+    "packages/pie-provider/dist"
   ],
   "engines": {
     "node": ">=24.2.0"
@@ -35,9 +28,10 @@
   "dependencies": {
     "@fastify/cors": "^11.1.0",
     "@fastify/websocket": "^11.0.2",
+    "@larksuiteoapi/node-sdk": "^1.72.0",
     "@noble/ciphers": "^2.2.0",
     "@noble/hashes": "^2.2.0",
-    "acpx": "^0.7.0",
+    "acpx": "^0.13.0",
     "fastify": "^5.6.2",
     "zod": "^4.4.2"
   },

package/packages/agent-sdk/dist/index.d.ts

@@ -18,6 +18,13 @@ export type AgentProfile = {
     label: string;
     command?: string;
     historyModel?: "append-only" | "authoritative-linear";
+    defaultModel?: string;
+    models?: Array<{
+        id: string;
+        label?: string;
+        unavailable?: boolean;
+        reason?: string;
+    }>;
     capabilities?: AgentCapability;
 };
 export type ProviderInfo = {
@@ -30,12 +37,20 @@ export type RuntimeHandle = {
     agent: string;
     sessionId: string;
     cwd?: string;
+    model?: string;
     opaque?: Record<string, unknown>;
 };
 export type RuntimeAttachment = {
+    name?: string;
     mediaType: string;
+    sizeBytes?: number;
     data: string;
 };
+export type RuntimeOptionChoice = {
+    id: string;
+    label: string;
+    description?: string;
+};
 export type RuntimeEvent = {
     type: "text_delta";
     text: string;
@@ -47,6 +62,16 @@ export type RuntimeEvent = {
     tag?: string;
     used?: number;
     size?: number;
+} | {
+    type: "session_usage";
+    source: "provider" | "estimated";
+    usedTokens: number;
+    contextWindowTokens?: number;
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedInputTokens?: number;
+    reasoningOutputTokens?: number;
+    totalTokens?: number;
 } | {
     type: "tool_call";
     text: string;
@@ -54,6 +79,13 @@ export type RuntimeEvent = {
     toolCallId?: string;
     status?: string;
     title?: string;
+} | {
+    type: "option_request";
+    optionRequestId: string;
+    title?: string;
+    message: string;
+    options: RuntimeOptionChoice[];
+    allowFreeText?: boolean;
 } | {
     type: "done";
     stopReason?: string;
@@ -85,6 +117,26 @@ export type RuntimeTurnResult = {
         retryable?: boolean;
     };
 };
+export type RuntimeTurnInspection = {
+    status: "active";
+    currentHead?: string;
+    lastTurnId?: string;
+    providerTurnId?: string;
+    evidence?: string;
+} | {
+    status: "terminal";
+    terminalStatus: "completed" | "cancelled" | "failed";
+    currentHead?: string;
+    lastTurnId?: string;
+    providerTurnId?: string;
+    error?: string;
+    evidence?: string;
+} | {
+    status: "unknown" | "not_found" | "uninspectable";
+    providerTurnId?: string;
+    reason?: string;
+    evidence?: string;
+};
 export interface RuntimeTurn {
     readonly requestId: string;
     readonly events: AsyncIterable<RuntimeEvent>;
@@ -92,6 +144,11 @@ export interface RuntimeTurn {
     cancel(input?: {
         reason?: string;
     }): Promise<void>;
+    respondOption?(input: {
+        optionRequestId: string;
+        selectedOptionId?: string;
+        text?: string;
+    }): Promise<void>;
     closeStream(input?: {
         reason?: string;
     }): Promise<void>;
@@ -174,6 +231,7 @@ export interface HappyElvesAgentProvider {
         resumeHandle?: RuntimeHandle;
         cwd?: string;
         permissionMode?: PermissionMode;
+        model?: string;
         restartableEmptySession?: boolean;
     }): Promise<RuntimeHandle>;
     startTurn(input: {
@@ -182,6 +240,7 @@ export interface HappyElvesAgentProvider {
         attachments?: RuntimeAttachment[];
         mode: PromptMode;
         permissionMode?: PermissionMode;
+        model?: string;
         requestId: string;
         timeoutMs?: number;
         signal?: AbortSignal;
@@ -195,6 +254,12 @@ export interface HappyElvesAgentProvider {
         reason: string;
         discardPersistentState?: boolean;
     }): Promise<void>;
+    inspectTurn?(input: {
+        handle: RuntimeHandle;
+        turnId?: string;
+        providerTurnId?: string;
+        requestId?: string;
+    }): Promise<RuntimeTurnInspection>;
     listHistoricalSessions?(input: {
         agent?: string;
         cwd?: string;
@@ -265,6 +330,16 @@ export type ProviderRequest = {
     id: string;
     method: "startTurn";
     params: Omit<Parameters<HappyElvesAgentProvider["startTurn"]>[0], "signal">;
+} | {
+    type: "request";
+    id: string;
+    method: "respondOption";
+    params: {
+        handle: RuntimeHandle;
+        optionRequestId: string;
+        selectedOptionId?: string;
+        text?: string;
+    };
 } | {
     type: "request";
     id: string;
@@ -275,6 +350,11 @@ export type ProviderRequest = {
     id: string;
     method: "close";
     params: Parameters<HappyElvesAgentProvider["close"]>[0];
+} | {
+    type: "request";
+    id: string;
+    method: "inspectTurn";
+    params: Parameters<NonNullable<HappyElvesAgentProvider["inspectTurn"]>>[0];
 } | {
     type: "request";
     id: string;

package/packages/agent-sdk/dist/index.js

@@ -68,6 +68,18 @@ async function dispatchRequest(provider, request, activeTurns) {
     switch (request.method) {
         case "startTurn":
             throw new ProviderError("INTERNAL_ERROR", "startTurn must be handled by the streaming dispatcher");
+        case "respondOption":
+            {
+                const activeTurn = activeTurns.get(runtimeHandleKey(request.params.handle));
+                if (!activeTurn?.respondOption)
+                    throw new ProviderError("UNSUPPORTED", "respondOption is not supported by this active turn");
+                await activeTurn.respondOption({
+                    optionRequestId: request.params.optionRequestId,
+                    selectedOptionId: request.params.selectedOptionId,
+                    text: request.params.text,
+                });
+                return undefined;
+            }
         case "getProviderInfo":
             return provider.getProviderInfo();
         case "listAgents":
@@ -85,6 +97,10 @@ async function dispatchRequest(provider, request, activeTurns) {
             return provider.cancel(request.params);
         case "close":
             return provider.close(request.params);
+        case "inspectTurn":
+            if (!provider.inspectTurn)
+                throw new ProviderError("UNSUPPORTED", "inspectTurn is not supported");
+            return provider.inspectTurn(request.params);
         case "listHistoricalSessions":
             if (!provider.listHistoricalSessions)
                 throw new ProviderError("UNSUPPORTED", "listHistoricalSessions is not supported");

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

@@ -1,5 +1,5 @@
-import { type PairingStartResponse } from "@happy-elves/shared";
-import type { AddControllerDeviceInput, AddControllerDeviceResult, ControllerClientConfig, ControllerInviteClaimInput, ControllerInviteClaimResult, ControllerInviteCreateInput, ControllerInviteCreateResult, CreateScopedTokenInput, DeviceListResponse, ScopedTokenInfo, ScopedTokenSelf } from "./types.js";
+import { type PairingStartResponse } from "../../shared/dist/index.js";
+import type { AddControllerDeviceInput, AddControllerDeviceResult, ControllerClientConfig, ControllerInviteClaimInput, ControllerInviteClaimResult, ControllerInviteCreateInput, ControllerInviteCreateResult, CreateScopedTokenInput, DeviceListResponse, EncryptedMemoryRecord, MemorySettings, RenameDeviceResult, ScopedTokenInfo, ScopedTokenSelf, WorkspaceCwdPin, WorkspaceCwdPinInput, WorkspaceProjectPreference, WorkspaceProjectPreferenceInput, WorkspaceRecentSession, WorkspaceSessionStarResult, WorkspaceSyncState } from "./types.js";
 export declare function listDevices(config: ControllerClientConfig): Promise<DeviceListResponse>;
 export declare function createPairingCode(config: ControllerClientConfig): Promise<PairingStartResponse>;
 export declare function addControllerDevice(config: ControllerClientConfig, input: AddControllerDeviceInput): Promise<AddControllerDeviceResult>;
@@ -9,6 +9,39 @@ export declare function revokeDevice(config: ControllerClientConfig, deviceId: s
     deviceId: string;
     revokedAt: number;
 }>;
+export declare function renameDevice(config: ControllerClientConfig, deviceId: string, name: string): Promise<RenameDeviceResult>;
+export declare function workspaceSyncState(config: ControllerClientConfig): Promise<WorkspaceSyncState>;
+export declare function setSessionStar(config: ControllerClientConfig, sessionId: string, starred: boolean): Promise<WorkspaceSessionStarResult>;
+export declare function markSessionRecent(config: ControllerClientConfig, sessionId: string): Promise<WorkspaceRecentSession>;
+export declare function pinWorkspaceCwd(config: ControllerClientConfig, input: WorkspaceCwdPinInput): Promise<WorkspaceCwdPin>;
+export declare function unpinWorkspaceCwd(config: ControllerClientConfig, input: Pick<WorkspaceCwdPinInput, "machineId" | "cwd">): Promise<{
+    machineId: string;
+    cwd: string;
+    removed: boolean;
+    removedAt: number;
+}>;
+export declare function setWorkspaceProjectPreference(config: ControllerClientConfig, input: WorkspaceProjectPreferenceInput): Promise<WorkspaceProjectPreference>;
+export declare function listEncryptedMemories(config: ControllerClientConfig, projectKey?: string): Promise<{
+    memories: EncryptedMemoryRecord[];
+}>;
+export declare function saveEncryptedMemory(config: ControllerClientConfig, input: {
+    id: string;
+    projectKey: string;
+    encryptedMemory: unknown;
+}): Promise<EncryptedMemoryRecord>;
+export declare function deleteMemory(config: ControllerClientConfig, id: string): Promise<{
+    id: string;
+    deleted: boolean;
+    deletedAt: number;
+}>;
+export declare function listMemorySettings(config: ControllerClientConfig, projectKey?: string): Promise<{
+    settings: MemorySettings[];
+}>;
+export declare function setMemorySettings(config: ControllerClientConfig, input: {
+    projectKey: string;
+    disabled?: boolean;
+    injectionEnabled?: boolean;
+}): Promise<MemorySettings>;
 export declare function tokenSelf(config: ControllerClientConfig): Promise<ScopedTokenSelf>;
 export declare function listScopedTokens(config: ControllerClientConfig): Promise<{
     tokens: ScopedTokenInfo[];

package/packages/client/dist/account.js

@@ -1,6 +1,6 @@
 import { base64UrlEncode, encryptJson, randomBytes } from "../../shared/dist/index.js";
 import { authenticatedJson, authenticatedJsonRaw, publicJsonRaw } from "./http.js";
-import { parseAddControllerDeviceResult, parseControllerInviteClaim, parseControllerInviteCreate, parseDevicesResponse, parsePairingStartResponse, parseRevokeDeviceResult, parseScopedTokenCreate, parseScopedTokenList, parseScopedTokenRevoke, parseScopedTokenSelf, } from "./parsers.js";
+import { parseAddControllerDeviceResult, parseControllerInviteClaim, parseControllerInviteCreate, parseDevicesResponse, parseMemoryDeleteResult, parseMemoryListResponse, parseMemorySaveResult, parseMemorySettingsList, parseMemorySettingsResult, parsePairingStartResponse, parseRenameDeviceResult, parseRevokeDeviceResult, parseScopedTokenCreate, parseScopedTokenList, parseScopedTokenRevoke, parseScopedTokenSelf, parseWorkspaceCwdPinResult, parseWorkspaceCwdUnpinResult, parseWorkspaceProjectPreferenceResult, parseWorkspaceRecentSessionResult, parseWorkspaceSessionStarResult, parseWorkspaceSyncState, } from "./parsers.js";
 import { requireNonEmpty } from "./validation.js";
 export async function listDevices(config) {
     return await authenticatedJson(config, "/api/devices", { method: "GET" }, parseDevicesResponse);
@@ -54,6 +54,103 @@ export async function revokeDevice(config, deviceId) {
         body: JSON.stringify({ deviceId: checkedDeviceId }),
     }, parseRevokeDeviceResult);
 }
+export async function renameDevice(config, deviceId, name) {
+    const checkedDeviceId = requireNonEmpty(deviceId, "deviceId");
+    const checkedName = requireNonEmpty(name, "name");
+    return await authenticatedJson(config, "/api/devices/rename", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ deviceId: checkedDeviceId, name: checkedName }),
+    }, parseRenameDeviceResult);
+}
+export async function workspaceSyncState(config) {
+    return await authenticatedJson(config, "/api/workspace-sync", { method: "GET" }, parseWorkspaceSyncState);
+}
+export async function setSessionStar(config, sessionId, starred) {
+    const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
+    return await authenticatedJson(config, "/api/workspace-sync/session-star", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ sessionId: checkedSessionId, starred }),
+    }, parseWorkspaceSessionStarResult);
+}
+export async function markSessionRecent(config, sessionId) {
+    const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
+    return await authenticatedJson(config, "/api/workspace-sync/session-recent", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ sessionId: checkedSessionId }),
+    }, parseWorkspaceRecentSessionResult);
+}
+export async function pinWorkspaceCwd(config, input) {
+    const machineId = requireNonEmpty(input.machineId, "machineId");
+    const cwd = requireNonEmpty(input.cwd, "cwd");
+    return await authenticatedJson(config, "/api/workspace-sync/cwd-pin", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ machineId, cwd, ...(input.label ? { label: input.label } : {}) }),
+    }, parseWorkspaceCwdPinResult);
+}
+export async function unpinWorkspaceCwd(config, input) {
+    const machineId = requireNonEmpty(input.machineId, "machineId");
+    const cwd = requireNonEmpty(input.cwd, "cwd");
+    return await authenticatedJson(config, "/api/workspace-sync/cwd-unpin", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ machineId, cwd }),
+    }, parseWorkspaceCwdUnpinResult);
+}
+export async function setWorkspaceProjectPreference(config, input) {
+    const projectKey = requireNonEmpty(input.projectKey, "projectKey");
+    return await authenticatedJson(config, "/api/workspace-sync/project-preference", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            projectKey,
+            ...(input.machineId ? { machineId: input.machineId } : {}),
+            ...(input.cwd ? { cwd: input.cwd } : {}),
+            ...(input.agent ? { agent: input.agent } : {}),
+            ...(input.memoryMode ? { memoryMode: input.memoryMode } : {}),
+        }),
+    }, parseWorkspaceProjectPreferenceResult);
+}
+export async function listEncryptedMemories(config, projectKey) {
+    const query = projectKey ? `?projectKey=${encodeURIComponent(projectKey)}` : "";
+    return await authenticatedJson(config, `/api/memory${query}`, { method: "GET" }, parseMemoryListResponse);
+}
+export async function saveEncryptedMemory(config, input) {
+    const id = requireNonEmpty(input.id, "id");
+    const projectKey = requireNonEmpty(input.projectKey, "projectKey");
+    return await authenticatedJson(config, "/api/memory", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ id, projectKey, encryptedMemory: input.encryptedMemory }),
+    }, parseMemorySaveResult);
+}
+export async function deleteMemory(config, id) {
+    const checkedId = requireNonEmpty(id, "id");
+    return await authenticatedJson(config, "/api/memory/delete", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ id: checkedId }),
+    }, parseMemoryDeleteResult);
+}
+export async function listMemorySettings(config, projectKey) {
+    const query = projectKey ? `?projectKey=${encodeURIComponent(projectKey)}` : "";
+    return await authenticatedJson(config, `/api/memory/settings${query}`, { method: "GET" }, parseMemorySettingsList);
+}
+export async function setMemorySettings(config, input) {
+    const projectKey = requireNonEmpty(input.projectKey, "projectKey");
+    return await authenticatedJson(config, "/api/memory/settings", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+            projectKey,
+            ...(input.disabled === undefined ? {} : { disabled: input.disabled }),
+            ...(input.injectionEnabled === undefined ? {} : { injectionEnabled: input.injectionEnabled }),
+        }),
+    }, parseMemorySettingsResult);
+}
 export async function tokenSelf(config) {
     return await authenticatedJson(config, "/api/scoped-tokens/self", { method: "GET" }, parseScopedTokenSelf);
 }

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

@@ -1,6 +1,6 @@
-import { type DirectoryListing, type EncryptedSessionEvent, type HistoricalSessionSnapshot, type MachineSnapshot, type PairingStartResponse, type SessionSnapshot } from "@happy-elves/shared";
+import { type DirectoryListing, type EncryptedSessionEvent, type EncryptedEnvelope, type HistoricalSessionSnapshot, type MachineSnapshot, type PairingStartResponse, type SessionSnapshot } from "../../shared/dist/index.js";
 import { sendCommand } from "./transport.js";
-import type { AddControllerDeviceInput, AddControllerDeviceResult, CancelInput, CollectInput, CommandResult, ControllerClientConfig, ControllerInviteClaimInput, ControllerInviteClaimResult, ControllerInviteCreateInput, ControllerInviteCreateResult, ControllerSnapshot, ControllerSubscriptionHandlers, CreateScopedTokenInput, CreateSessionInput, DecodedSessionEvent, DecodedSessionEventsPage, DeviceListResponse, DirectoryInput, FilePreviewInput, ForkInput, HistoricalSessionListPage, HistoricalSessionsInput, ImportHistoricalSessionInput, MachineMetadata, MachineDevExecInput, MachineDevExecResponse, MachineDiagnosticsResponse, RunOptions, ScopedTokenInfo, ScopedTokenSelf, SessionFilter, SessionMetadata, WaitInput } from "./types.js";
+import type { AddControllerDeviceInput, AddControllerDeviceResult, CancelInput, CollectInput, CommandResult, ControllerClientConfig, ControllerInviteClaimInput, ControllerInviteClaimResult, ControllerInviteCreateInput, ControllerInviteCreateResult, ControllerSnapshot, ControllerSubscriptionHandlers, CreateScopedTokenInput, CreateSessionInput, DecodedSessionEvent, DecodedSessionEventsPage, DeviceListResponse, DirectoryInput, FilePreviewInput, ForkInput, GatewayCommandInput, GatewayCommandResponse, HistoricalSessionListPage, HistoricalSessionsInput, ImportHistoricalSessionInput, MachineMetadata, MachineDevExecInput, MachineDevExecResponse, MachineDiagnosticsResponse, MemoryCommandInput, MemoryCommandResponse, DecodedMemoryRecord, RepairSessionHeadInput, RepairSessionHeadResult, RunOptions, ScheduleCommandInput, ScheduleCommandResponse, ScopedTokenInfo, ScopedTokenSelf, SessionFilter, SessionMetadata, WaitInput, MemorySaveInput, MemorySearchInput, MemorySettings, TurnReconcileResponse, WorkspaceCwdPin, WorkspaceCwdPinInput, WorkspaceProjectPreference, WorkspaceProjectPreferenceInput, WorkspaceRecentSession, WorkspaceSessionStarResult, WorkspaceSyncState } from "./types.js";
 export declare class ControllerClient {
     readonly config: ControllerClientConfig;
     constructor(config: ControllerClientConfig);
@@ -15,6 +15,37 @@ export declare class ControllerClient {
         deviceId: string;
         revokedAt: number;
     }>;
+    renameDevice(deviceId: string, name: string): Promise<{
+        deviceId: string;
+        name: string;
+        renamedAt: number;
+    }>;
+    workspaceSync(): Promise<WorkspaceSyncState>;
+    starSession(sessionId: string): Promise<WorkspaceSessionStarResult>;
+    unstarSession(sessionId: string): Promise<WorkspaceSessionStarResult>;
+    markSessionRecent(sessionId: string): Promise<WorkspaceRecentSession>;
+    pinWorkspaceCwd(input: WorkspaceCwdPinInput): Promise<WorkspaceCwdPin>;
+    unpinWorkspaceCwd(input: Pick<WorkspaceCwdPinInput, "machineId" | "cwd">): Promise<{
+        machineId: string;
+        cwd: string;
+        removed: boolean;
+        removedAt: number;
+    }>;
+    setWorkspaceProjectPreference(input: WorkspaceProjectPreferenceInput): Promise<WorkspaceProjectPreference>;
+    saveMemory(input: MemorySaveInput): Promise<DecodedMemoryRecord>;
+    listMemories(projectKey?: string): Promise<DecodedMemoryRecord[]>;
+    searchMemories(input: MemorySearchInput): Promise<DecodedMemoryRecord[]>;
+    deleteMemory(id: string): Promise<{
+        id: string;
+        deleted: boolean;
+        deletedAt: number;
+    }>;
+    memorySettings(projectKey?: string): Promise<MemorySettings[]>;
+    setMemorySettings(input: {
+        projectKey: string;
+        disabled?: boolean;
+        injectionEnabled?: boolean;
+    }): Promise<MemorySettings>;
     tokenSelf(): Promise<ScopedTokenSelf>;
     listScopedTokens(): Promise<{
         tokens: ScopedTokenInfo[];
@@ -31,31 +62,53 @@ export declare class ControllerClient {
     getSession(sessionId: string): Promise<SessionSnapshot | undefined>;
     history(sessionId: string, limit?: number): Promise<DecodedSessionEvent[]>;
     createSession(input: CreateSessionInput): Promise<CommandResult>;
+    updateSessionMetadata(sessionId: string, metadata: SessionMetadata): Promise<SessionSnapshot>;
+    setSessionTags(sessionId: string, tags: readonly unknown[]): Promise<{
+        session: SessionSnapshot;
+        tags: string[];
+    }>;
+    findLoadedRuntimeSession(input: {
+        machineId: string;
+        agent: string;
+        runtimeSessionId: string;
+    }): Promise<SessionSnapshot | undefined>;
     collect(sessionId: string, input?: CollectInput): Promise<DecodedSessionEvent[]>;
     collectPage(sessionId: string, input?: CollectInput): Promise<DecodedSessionEventsPage>;
+    repairSessionHead(sessionId: string, input: RepairSessionHeadInput): Promise<RepairSessionHeadResult>;
     wait(sessionId: string, input?: WaitInput): Promise<SessionSnapshot>;
-    resume(sessionId: string): Promise<CommandResult>;
+    resume(sessionId: string, options?: {
+        syncDirection?: "latest" | "older";
+    }): Promise<CommandResult>;
     listHistoricalSessionsPage(input: HistoricalSessionsInput): Promise<HistoricalSessionListPage>;
     listHistoricalSessions(input: HistoricalSessionsInput): Promise<HistoricalSessionSnapshot[]>;
     listDirectory(input: DirectoryInput): Promise<DirectoryListing>;
-    previewFile(input: FilePreviewInput): Promise<import("@happy-elves/shared").FilePreviewResult>;
+    previewFile(input: FilePreviewInput): Promise<import("../../shared/dist/index.js").FilePreviewResult>;
     machineDiagnostics(machineId: string): Promise<MachineDiagnosticsResponse>;
     machineDevExec(input: MachineDevExecInput): Promise<MachineDevExecResponse>;
+    gateway(input: GatewayCommandInput): Promise<GatewayCommandResponse>;
+    schedule(input: ScheduleCommandInput): Promise<ScheduleCommandResponse>;
+    memory(input: MemoryCommandInput): Promise<MemoryCommandResponse>;
     importHistoricalSession(input: ImportHistoricalSessionInput): Promise<CommandResult>;
     rewind(sessionId: string, to: string): Promise<CommandResult>;
     fork(sessionId: string, input: ForkInput): Promise<CommandResult>;
     renameSession(sessionId: string, name: string): Promise<CommandResult>;
     run(sessionId: string, text: string, options?: RunOptions): Promise<CommandResult>;
+    reconcileTurn(sessionId: string, turnId?: string): Promise<TurnReconcileResponse>;
     cancel(sessionId: string, input?: CancelInput): Promise<CommandResult>;
     close(sessionId: string, reason?: string): Promise<CommandResult>;
     subscribe(handlers: ControllerSubscriptionHandlers): WebSocket;
     decodeEvents(events: EncryptedSessionEvent[]): Promise<DecodedSessionEvent[]>;
     decodeMachineMetadata(machine: MachineSnapshot): Promise<MachineMetadata>;
     decodeSessionMetadata(session: SessionSnapshot): Promise<SessionMetadata>;
+    decodeMemory(memory: {
+        id: string;
+        projectKey: string;
+        encryptedMemory: EncryptedEnvelope;
+        createdAt: number;
+        updatedAt: number;
+    }): Promise<DecodedMemoryRecord>;
     sendCommand(command: Parameters<typeof sendCommand>[1], waitForDone?: boolean, timeoutMs?: number): Promise<CommandResult>;
     private waitForCreatedSession;
-    private recoverCreatedSessionName;
-    private waitForSessionName;
     private waitForRunSettlement;
     private mergeReplayedTurnEvents;
     private sessionEvents;