@cydm/happy-elves 0.1.0-beta.37 → 0.1.0-beta.39

package/apps/cli/dist/commands/lib/args.js

@@ -61,6 +61,7 @@ const booleanFlags = new Set([
     "local",
     "no-open",
     "no-wait",
+    "repair-head",
     "summary",
     "verbose",
     "wait",

package/apps/cli/dist/commands/lib/session-output.d.ts

@@ -1,6 +1,7 @@
 import type { ControllerClient, DecodedSessionEvent } from "../../../../../packages/client/dist/index.js";
 export declare function compactText(value: string, max?: number): string;
 export declare function lastAssistantOutput(events: DecodedSessionEvent[]): string;
+export declare function compareSessionEventLogicalOrder(left: DecodedSessionEvent, right: DecodedSessionEvent): number;
 export declare function displayPath(filePath: string): string;
 export type StoredTurnOutput = {
     sessionId: string;

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

@@ -48,6 +48,27 @@ function assistantOutputForTurn(events, turnId) {
         .join("")
         .trim();
 }
+function sessionEventLogicalOrder(event) {
+    const messageKey = event.messageId ?? "";
+    if (event.occurredAt !== undefined) {
+        return { time: event.occurredAt, seq: event.turnSeq ?? event.seq, messageKey, id: event.id };
+    }
+    if (event.messageId?.startsWith("hist_") && event.turnSeq !== undefined) {
+        return { time: 0, seq: event.turnSeq, messageKey, id: event.id };
+    }
+    return { time: event.createdAt, seq: event.seq, messageKey, id: event.id };
+}
+export function compareSessionEventLogicalOrder(left, right) {
+    const leftOrder = sessionEventLogicalOrder(left);
+    const rightOrder = sessionEventLogicalOrder(right);
+    if (leftOrder.time !== rightOrder.time)
+        return leftOrder.time - rightOrder.time;
+    if (leftOrder.seq !== rightOrder.seq)
+        return leftOrder.seq - rightOrder.seq;
+    if (leftOrder.messageKey !== rightOrder.messageKey)
+        return leftOrder.messageKey < rightOrder.messageKey ? -1 : 1;
+    return leftOrder.id - rightOrder.id;
+}
 function outputPaths(sessionId, turnId) {
     const dir = path.join(outputRoot, sessionId);
     const latest = path.join(dir, "latest.md");
@@ -142,8 +163,9 @@ export async function readStoredTurnOutput(sessionId, turnId) {
 export function summarizeTurns(events) {
     const folded = foldAliasedRuntimeEvents(events);
     const turns = new Map();
-    const sorted = [...folded.events].sort((left, right) => left.id - right.id);
+    const sorted = [...folded.events].sort(compareSessionEventLogicalOrder);
     for (const event of sorted) {
+        const order = sessionEventLogicalOrder(event);
         const current = turns.get(event.turnId) ?? {
             turnId: event.turnId,
             promptChunks: [],
@@ -155,11 +177,13 @@ export function summarizeTurns(events) {
             firstEventId: event.id,
             lastEventId: event.id,
             eventCount: 0,
+            order,
         };
         current.startedAt ??= event.createdAt;
         current.updatedAt = event.createdAt;
         current.lastEventId = event.id;
         current.eventCount += 1;
+        current.order = order;
         if (event.turnSeq !== undefined)
             current.turnSeq = event.turnSeq;
         const payload = event.decoded;
@@ -194,8 +218,14 @@ export function summarizeTurns(events) {
         firstEventId: turn.firstEventId,
         lastEventId: turn.lastEventId,
         eventCount: turn.eventCount,
+        order: turn.order,
     }))
-        .sort((left, right) => right.updatedAt - left.updatedAt || right.lastEventId - left.lastEventId);
+        .sort((left, right) => right.order.time - left.order.time ||
+        right.order.seq - left.order.seq ||
+        (right.order.messageKey === left.order.messageKey ? 0 : right.order.messageKey < left.order.messageKey ? -1 : 1) ||
+        right.order.id - left.order.id ||
+        right.lastEventId - left.lastEventId)
+        .map(({ order: _order, ...turn }) => turn);
 }
 export function structuredOutputForTurn(sessionId, turn) {
     const finalOutput = turn.output || turn.terminalText || undefined;

package/apps/cli/dist/commands/lib/usage.js

@@ -50,7 +50,7 @@ Check local controller config, relay reachability, and daemon state.
   happy-elves session history --machine <machineId> [--cwd <path>] [--agent <agent>] [--include-archived] [--limit 20] --json
   happy-elves session continue <runtimeSessionId> --machine <machineId> [--name <name>] --json
   happy-elves session status <sessionId> [--verbose] [--json]
-  happy-elves session diagnose <sessionId> [--limit 200] [--json]
+  happy-elves session diagnose <sessionId> [--limit 200] [--repair-head] [--json]
   happy-elves session close <sessionId> [--reason <reason>] --json
 
 Session management:
@@ -62,7 +62,8 @@ Session management:
   existing loaded session if it already exists.
   diagnose reports the selected session's runtime handle metadata, backfill
   counters, and latest materialized relay page counts for debugging empty or
-  stale transcripts.
+  stale transcripts. --repair-head advances a stale canonical head to the
+  latest completed relay event when the relay already has the event basis.
   close archives a loaded session. There is no separate archive command.
 `,
     turn: `Usage:
@@ -141,7 +142,7 @@ Core commands:
   session history --machine <machineId> [--cwd <path>] [--limit 20] --json
   session continue <runtimeSessionId> --machine <machineId> --json
   session status <sessionId> [--verbose] [--json]
-  session diagnose <sessionId> [--limit 200] [--json]
+  session diagnose <sessionId> [--limit 200] [--repair-head] [--json]
   session close <sessionId> [--reason <reason>] --json
 
   turn list <sessionId> [--limit 10] [--json]

package/apps/cli/dist/commands/session.js

@@ -1,4 +1,4 @@
-import { CliError, ControllerClient, compactSessionListItem, compactText, conciseSessionSummary, deriveOrchestration, listWorkspaceHistoricalSessions, ok, parsePermissionMode, readConfig, readStoredTurnOutput, requirePositional, requireString, showSession, structuredSessionProjection, summarizeTurns, wantsJson, wantsVerbose } from "./lib/index.js";
+import { CliError, ControllerClient, compareSessionEventLogicalOrder, compactSessionListItem, compactText, conciseSessionSummary, deriveOrchestration, listWorkspaceHistoricalSessions, ok, parsePermissionMode, readConfig, readStoredTurnOutput, requirePositional, requireString, showSession, structuredSessionProjection, summarizeTurns, wantsJson, wantsVerbose } from "./lib/index.js";
 function formatTurnTimestamp(value) {
     return value === undefined ? "-" : new Date(value).toISOString();
 }
@@ -104,6 +104,35 @@ function compactEventDiagnostic(event) {
         ...(event.turnSeq !== undefined ? { turnSeq: event.turnSeq } : {}),
     };
 }
+function repairHeadInputForLatestCompletedEvent(events) {
+    const doneEvent = [...events]
+        .sort(compareSessionEventLogicalOrder)
+        .reverse()
+        .find((event) => event.decoded?.type === "done" && event.decoded.status === "completed");
+    const done = doneEvent?.decoded;
+    if (!doneEvent || done?.type !== "done") {
+        throw new CliError("No completed done event is available for head repair", "SESSION_HEAD_REPAIR_UNAVAILABLE");
+    }
+    if (!doneEvent.messageId) {
+        throw new CliError("Latest completed done event has no messageId basis", "SESSION_HEAD_REPAIR_UNAVAILABLE");
+    }
+    const turnSeq = doneEvent.turnSeq;
+    if (turnSeq === undefined) {
+        throw new CliError("Latest completed done event has no turnSeq basis", "SESSION_HEAD_REPAIR_UNAVAILABLE");
+    }
+    const currentHead = done.currentHead ?? done.lastTurnId ?? doneEvent.turnId;
+    const lastTurnId = done.lastTurnId ?? done.currentHead ?? doneEvent.turnId;
+    return {
+        currentHead,
+        lastTurnId,
+        basis: {
+            turnId: doneEvent.turnId,
+            eventMessageId: doneEvent.messageId,
+            turnSeq,
+            ...(doneEvent.occurredAt === undefined ? {} : { occurredAt: doneEvent.occurredAt }),
+        },
+    };
+}
 function eventCollectionDiagnostics(events) {
     return {
         decryptErrors: events.filter((event) => event.decryptError).length,
@@ -330,15 +359,24 @@ export async function handleSession({ domain, action, positional, flags }) {
         const limit = parsePositiveIntFlag(flags, "limit") ?? 200;
         const client = await makeClient();
         const snapshot = await client.snapshot();
-        const session = snapshot.sessions.find((item) => item.id === sessionId);
-        if (!session)
+        const initialSession = snapshot.sessions.find((item) => item.id === sessionId);
+        if (!initialSession)
             throw new CliError("Session not found", "SESSION_NOT_FOUND");
+        let session = initialSession;
+        if (flags["repair-head"] === true && session.status === "running") {
+            throw new CliError("Cannot repair a running session head", "SESSION_HEAD_REPAIR_RUNNING");
+        }
         const machine = snapshot.machines.find((item) => item.id === session.machineId);
         const metadata = await client.decodeSessionMetadata(session);
         const latestPage = await client.collectPage(session.id, { limit });
         const turns = summarizeTurns(latestPage.events);
         const latestCompletedTurn = turns.find((turn) => turn.status === "completed");
         const latestTerminalTurn = turns.find((turn) => turn.status !== "running");
+        const repair = flags["repair-head"] === true
+            ? await client.repairSessionHead(session.id, repairHeadInputForLatestCompletedEvent(latestPage.events))
+            : undefined;
+        if (repair)
+            session = repair.session;
         const data = {
             generatedAt: new Date().toISOString(),
             session: {
@@ -395,6 +433,13 @@ export async function handleSession({ domain, action, positional, flags }) {
                 staleHeadSuspected: staleHeadSuspected(session, latestCompletedTurn),
                 headMatchesLatestCompletedTurn: headMatchesTurn(session, latestCompletedTurn),
             },
+            repair: repair ? {
+                advanced: repair.advanced,
+                basis: repair.basis,
+                currentHead: repair.session.currentHead,
+                lastTurnId: repair.session.lastTurnId,
+                reason: repair.reason,
+            } : undefined,
         };
         if (wantsJson(flags) || wantsVerbose(flags)) {
             ok("session.diagnose", data, { machineId: session.machineId, sessionId: session.id });

package/apps/daemon/package.json

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

package/apps/relay/dist/http-routes.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { encryptedEnvelopeSchema, pairingCode, randomId, } from "../../../packages/shared/dist/index.js";
-import { controllerDeviceSchema, controllerInviteClaimSchema, controllerInviteCreateSchema, deviceRevokeSchema, pairingClaimSchema, pairingStartSchema, scopedTokenCreateSchema, scopedTokenRevokeSchema, sessionEventsQuerySchema, } from "./http-schemas.js";
+import { controllerDeviceSchema, controllerInviteClaimSchema, controllerInviteCreateSchema, deviceRevokeSchema, pairingClaimSchema, pairingStartSchema, scopedTokenCreateSchema, scopedTokenRevokeSchema, sessionHeadAdvanceSchema, sessionEventsQuerySchema, } from "./http-schemas.js";
 import { HttpError } from "./errors.js";
 import { encodePairingCode, isPairingCodeMatch, tokenDigest } from "./security.js";
 const visibleSessionEventWhere = `
@@ -238,6 +238,65 @@ export function registerHttpRoutes(app, context, controllerInviteTtlMs) {
             newestEventId: newestRow?.id,
         };
     });
+    app.post("/api/sessions/:sessionId/head", async (request) => {
+        const token = context.requireHttpToken(request.headers.authorization, "controller");
+        context.assertHttpScopedAction(token, "session.repairHead");
+        const params = z.object({ sessionId: z.string().min(1) }).parse(request.params);
+        const body = sessionHeadAdvanceSchema.parse(request.body);
+        context.assertScopedSession(context.tokenScope(token), token.account_id, params.sessionId);
+        const session = context.db
+            .prepare("SELECT * FROM sessions WHERE account_id = ? AND id = ?")
+            .get(token.account_id, params.sessionId);
+        if (!session)
+            throw new HttpError(404, "SESSION_NOT_FOUND", "Session not found");
+        if (session.status === "running") {
+            throw new HttpError(409, "SESSION_HEAD_REPAIR_RUNNING", "Cannot repair a running session head");
+        }
+        const basisEvent = context.db
+            .prepare(`SELECT * FROM session_events
+         WHERE account_id = ? AND session_id = ? AND machine_id = ? AND message_id = ?`)
+            .get(token.account_id, params.sessionId, session.machine_id, body.basis.eventMessageId);
+        if (!basisEvent)
+            throw new HttpError(409, "SESSION_HEAD_BASIS_MISSING", "Head advance basis event is not available");
+        if (basisEvent.turn_id !== body.basis.turnId || basisEvent.turn_seq !== body.basis.turnSeq) {
+            throw new HttpError(409, "SESSION_HEAD_BASIS_MISMATCH", "Head advance basis does not match the stored event");
+        }
+        const nextOrder = logicalEventOrderForRow(basisEvent);
+        const currentOrder = sessionHeadBasisOrderForRow(context.db, session);
+        const rewriteFenced = typeof session.head_basis_message_id === "string" &&
+            session.head_basis_message_id.startsWith("rewrite:");
+        const advanced = !rewriteFenced && compareHeadOrders(nextOrder, currentOrder) > 0;
+        if (advanced) {
+            const ts = context.now();
+            context.db.prepare(`UPDATE sessions
+         SET current_head = ?,
+             last_turn_id = ?,
+             head_basis_event_id = ?,
+             head_basis_message_id = ?,
+             head_basis_logical_time = ?,
+             head_basis_turn_seq = ?,
+             updated_at = ?
+         WHERE id = ? AND account_id = ?`).run(body.currentHead, body.lastTurnId, basisEvent.id, basisEvent.message_id, nextOrder.time, nextOrder.seq, ts, params.sessionId, token.account_id);
+        }
+        const row = context.db
+            .prepare("SELECT * FROM sessions WHERE account_id = ? AND id = ?")
+            .get(token.account_id, params.sessionId);
+        if (!row)
+            throw new HttpError(404, "SESSION_NOT_FOUND", "Session not found");
+        const snapshot = context.sessionSnapshot(row);
+        context.broadcastControllers(token.account_id, { type: "server:session", session: snapshot });
+        return {
+            advanced,
+            session: snapshot,
+            basis: {
+                eventId: basisEvent.id,
+                messageId: basisEvent.message_id ?? undefined,
+                logicalTime: nextOrder.time,
+                turnSeq: nextOrder.seq,
+            },
+            ...(rewriteFenced ? { reason: "rewrite-fenced" } : {}),
+        };
+    });
     app.get("/api/devices", async (request) => {
         const token = context.requireFullControllerToken(request.headers.authorization);
         const rows = context.db
@@ -392,4 +451,40 @@ export function registerHttpRoutes(app, context, controllerInviteTtlMs) {
         return { tokenId: body.tokenId, revokedAt: target.revoked_at ?? ts };
     });
 }
+function compareHeadOrders(next, current) {
+    if (!current)
+        return 1;
+    if (next.time !== current.time)
+        return next.time > current.time ? 1 : -1;
+    if (next.seq !== current.seq)
+        return next.seq > current.seq ? 1 : -1;
+    if (next.id !== current.id)
+        return next.id > current.id ? 1 : -1;
+    return 0;
+}
+function logicalEventOrderForRow(row) {
+    if (row.occurred_at !== null && row.occurred_at !== undefined) {
+        return { time: row.occurred_at, seq: row.turn_seq ?? row.seq, id: row.id };
+    }
+    if (row.message_id?.startsWith("hist_") && row.turn_seq !== null && row.turn_seq !== undefined) {
+        return { time: 0, seq: row.turn_seq, id: row.id };
+    }
+    return { time: row.created_at, seq: row.turn_seq ?? row.seq, id: row.id };
+}
+function sessionHeadBasisOrderForRow(db, row) {
+    if (row.head_basis_logical_time !== null && row.head_basis_turn_seq !== null) {
+        return {
+            time: row.head_basis_logical_time,
+            seq: row.head_basis_turn_seq,
+            id: row.head_basis_event_id ?? 0,
+        };
+    }
+    const eventId = row.current_head ? /^event:(\d+)$/.exec(row.current_head)?.[1] : undefined;
+    if (!eventId)
+        return undefined;
+    const event = db
+        .prepare("SELECT * FROM session_events WHERE account_id = ? AND session_id = ? AND machine_id = ? AND id = ?")
+        .get(row.account_id, row.id, row.machine_id, Number(eventId));
+    return event ? logicalEventOrderForRow(event) : undefined;
+}
 //# sourceMappingURL=http-routes.js.map

package/apps/relay/dist/http-schemas.d.ts

@@ -46,3 +46,13 @@ export declare const sessionEventsQuerySchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     since: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
 }, z.core.$strip>;
+export declare const sessionHeadAdvanceSchema: z.ZodObject<{
+    currentHead: z.ZodString;
+    lastTurnId: z.ZodString;
+    basis: z.ZodObject<{
+        turnId: z.ZodString;
+        eventMessageId: z.ZodString;
+        turnSeq: z.ZodNumber;
+        occurredAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/apps/relay/dist/http-schemas.js

@@ -53,4 +53,14 @@ export const sessionEventsQuerySchema = z.object({
 }).refine((query) => query.beforeCursor === undefined || query.since === undefined, {
     message: "since and beforeCursor cannot both be provided",
 });
+export const sessionHeadAdvanceSchema = z.object({
+    currentHead: z.string().min(1),
+    lastTurnId: z.string().min(1),
+    basis: z.object({
+        turnId: z.string().min(1),
+        eventMessageId: z.string().min(1),
+        turnSeq: z.number().int().min(0),
+        occurredAt: z.number().int().optional(),
+    }),
+});
 //# sourceMappingURL=http-schemas.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.37",
+  "version": "0.1.0-beta.39",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
     "README.md",
     "apps/cli/dist",
     "apps/daemon/dist",
+    "apps/daemon/package.json",
     "apps/relay/dist",
     "packages/shared/dist",
     "packages/client/dist",

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 "../../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, HistoricalSessionListPage, HistoricalSessionsInput, ImportHistoricalSessionInput, MachineMetadata, MachineDevExecInput, MachineDevExecResponse, MachineDiagnosticsResponse, RepairSessionHeadInput, RepairSessionHeadResult, RunOptions, ScopedTokenInfo, ScopedTokenSelf, SessionFilter, SessionMetadata, WaitInput } from "./types.js";
 export declare class ControllerClient {
     readonly config: ControllerClientConfig;
     constructor(config: ControllerClientConfig);
@@ -33,6 +33,7 @@ export declare class ControllerClient {
     createSession(input: CreateSessionInput): Promise<CommandResult>;
     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>;
     listHistoricalSessionsPage(input: HistoricalSessionsInput): Promise<HistoricalSessionListPage>;

package/packages/client/dist/client.js

@@ -2,7 +2,7 @@ import { decryptJson, encryptJson, normalizeSessionName, parseServerMessage, ran
 import { addControllerDevice, claimControllerInvite, createControllerInvite, createPairingCode, createScopedToken, listDevices, listScopedTokens, revokeDevice, revokeScopedToken, tokenSelf, } from "./account.js";
 import { ControllerClientError, ControllerCommandError } from "./errors.js";
 import { authenticatedJson, normalizeRelayUrl, readRelayJson, relayHttpError } from "./http.js";
-import { parseSessionEventsResponse, } from "./parsers.js";
+import { parseRepairSessionHeadResult, parseSessionEventsResponse, } from "./parsers.js";
 import { sendAndWaitForDirectoryListing, sendAndWaitForFilePreview, sendAndWaitForHistoricalSessions, sendAndWaitForMachineDevExecResult, sendAndWaitForMachineDiagnostics, sendCommand, subscribe, } from "./transport.js";
 import { DEFAULT_SESSION_CREATE_WAIT_MS, } from "./types.js";
 import { isWaitCondition, matchesWaitCondition, parseEventCursor, parseEventLimit, parsePositiveDuration, requireNonEmpty, sleep, } from "./validation.js";
@@ -161,6 +161,27 @@ export class ControllerClient {
             ...(page.oldestEventId === undefined ? {} : { oldestEventId: page.oldestEventId }),
         };
     }
+    async repairSessionHead(sessionId, input) {
+        const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
+        const currentHead = requireNonEmpty(input.currentHead, "currentHead");
+        const lastTurnId = requireNonEmpty(input.lastTurnId, "lastTurnId");
+        const turnId = requireNonEmpty(input.basis.turnId, "basis.turnId");
+        const eventMessageId = requireNonEmpty(input.basis.eventMessageId, "basis.eventMessageId");
+        return await authenticatedJson(this.config, `/api/sessions/${encodeURIComponent(checkedSessionId)}/head`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                currentHead,
+                lastTurnId,
+                basis: {
+                    turnId,
+                    eventMessageId,
+                    turnSeq: input.basis.turnSeq,
+                    ...(input.basis.occurredAt === undefined ? {} : { occurredAt: input.basis.occurredAt }),
+                },
+            }),
+        }, parseRepairSessionHeadResult);
+    }
     async wait(sessionId, input = {}) {
         const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
         const until = input.until ?? "idle";

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

@@ -1,4 +1,4 @@
 export { ControllerClient } from "./client.js";
 export { ControllerClientError, ControllerCommandError } from "./errors.js";
-export type { AddControllerDeviceInput, AddControllerDeviceResult, CancelInput, CollectInput, CommandResult, ControllerClientConfig, ControllerDevice, ControllerInviteClaimInput, ControllerInviteClaimResult, ControllerInviteCreateInput, ControllerInviteCreateResult, ControllerSnapshot, ControllerSubscriptionHandlers, CreateScopedTokenInput, CreateSessionInput, DecodedSessionEvent, DecodedSessionEventsPage, DeviceListResponse, DirectoryInput, DirectoryListResponse, FilePreviewInput, FilePreviewResponse, EventCursor, ForkInput, HistoricalSessionListPage, HistoricalSessionListResponse, HistoricalSessionsInput, ImportHistoricalSessionInput, MachineListResponse, MachineMetadata, PermissionMode, RunOptions, ScopedTokenInfo, ScopedTokenScope, ScopedTokenSelf, SessionFilter, SessionMetadata, WaitCondition, WaitInput, } from "./types.js";
+export type { AddControllerDeviceInput, AddControllerDeviceResult, CancelInput, CollectInput, CommandResult, ControllerClientConfig, ControllerDevice, ControllerInviteClaimInput, ControllerInviteClaimResult, ControllerInviteCreateInput, ControllerInviteCreateResult, ControllerSnapshot, ControllerSubscriptionHandlers, CreateScopedTokenInput, CreateSessionInput, DecodedSessionEvent, DecodedSessionEventsPage, DeviceListResponse, DirectoryInput, DirectoryListResponse, FilePreviewInput, FilePreviewResponse, EventCursor, ForkInput, HistoricalSessionListPage, HistoricalSessionListResponse, HistoricalSessionsInput, ImportHistoricalSessionInput, MachineListResponse, MachineMetadata, PermissionMode, RepairSessionHeadInput, RepairSessionHeadResult, RunOptions, ScopedTokenInfo, ScopedTokenScope, ScopedTokenSelf, SessionFilter, SessionMetadata, WaitCondition, WaitInput, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,5 +1,5 @@
 import { type PairingStartResponse } from "../../shared/dist/index.js";
-import type { AddControllerDeviceResult, ControllerInviteClaimResult, ControllerInviteCreateResult, DeviceListResponse, ScopedTokenInfo, ScopedTokenSelf, SessionEventsResponse } from "./types.js";
+import type { AddControllerDeviceResult, ControllerInviteClaimResult, ControllerInviteCreateResult, DeviceListResponse, ScopedTokenInfo, ScopedTokenSelf, RepairSessionHeadResult, SessionEventsResponse } from "./types.js";
 export declare function parsePairingStartResponse(value: unknown): PairingStartResponse;
 export declare function parseDevicesResponse(value: unknown): DeviceListResponse;
 export declare function parseAddControllerDeviceResult(value: unknown): AddControllerDeviceResult;
@@ -22,4 +22,5 @@ export declare function parseScopedTokenRevoke(value: unknown): {
     revokedAt: number;
 };
 export declare function parseSessionEventsResponse(value: unknown): SessionEventsResponse;
+export declare function parseRepairSessionHeadResult(value: unknown): RepairSessionHeadResult;
 //# sourceMappingURL=parsers.d.ts.map

package/packages/client/dist/parsers.js

@@ -175,4 +175,22 @@ 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"),
+        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/types.d.ts

@@ -202,6 +202,27 @@ export type CollectInput = {
     since?: EventCursor;
     limit?: number;
 };
+export type RepairSessionHeadInput = {
+    currentHead: string;
+    lastTurnId: string;
+    basis: {
+        turnId: string;
+        eventMessageId: string;
+        turnSeq: number;
+        occurredAt?: number;
+    };
+};
+export type RepairSessionHeadResult = {
+    advanced: boolean;
+    session: SessionSnapshot;
+    basis: {
+        eventId: number;
+        messageId?: string;
+        logicalTime: number;
+        turnSeq: number;
+    };
+    reason?: string;
+};
 export type ControllerInviteCreateInput = {
     deviceName?: string;
     ttlMs?: number;