@linkshell/wire 0.1.2 → 0.2.0

package/dist/direct.d.ts

@@ -0,0 +1,22 @@
+/** The data channel both sides use. */
+export declare const DIRECT_LABEL = "linkshell-bulk";
+/** The most stream bytes in one message: every WebRTC stack takes this size. */
+export declare const DIRECT_CHUNK: number;
+/**
+ * STUN servers used when a host names none: they only tell each side its
+ * public address. (Several, because none of them is reachable everywhere.)
+ */
+export declare const DEFAULT_ICE_SERVERS: string[];
+export type DirectFrame = {
+    type: "data";
+    stream: number;
+    data: Uint8Array;
+}
+/** The sender's end of the stream is finished (`error`: why, when it broke). */
+ | {
+    type: "close";
+    stream: number;
+    error?: string;
+};
+export declare function encodeDirectFrame(frame: DirectFrame): Uint8Array;
+export declare function decodeDirectFrame(bytes: Uint8Array): DirectFrame | undefined;

package/dist/direct.js

@@ -0,0 +1,37 @@
+// The direct channel: bulk streams (the screen, port previews) go from the
+// computer to the device peer to peer, over a WebRTC data channel, instead of
+// through the gateway. The offer and answer travel over the end-to-end
+// encrypted RPC channel, so the gateway can neither read them nor stand in for
+// either side; it carries only what little sets the connection up. When no
+// direct path can be made, the streams stay on the RPC channel as before.
+/** The data channel both sides use. */
+export const DIRECT_LABEL = "linkshell-bulk";
+/** The most stream bytes in one message: every WebRTC stack takes this size. */
+export const DIRECT_CHUNK = 16 * 1024;
+/**
+ * STUN servers used when a host names none: they only tell each side its
+ * public address. (Several, because none of them is reachable everywhere.)
+ */
+export const DEFAULT_ICE_SERVERS = ["stun:stun.cloudflare.com:3478", "stun:stun.chat.bilibili.com:3478", "stun:stun.l.google.com:19302"];
+const DATA = 1;
+const CLOSE = 2;
+export function encodeDirectFrame(frame) {
+    const payload = frame.type === "data" ? frame.data : new TextEncoder().encode(frame.error ?? "");
+    const bytes = new Uint8Array(5 + payload.length);
+    bytes[0] = frame.type === "data" ? DATA : CLOSE;
+    new DataView(bytes.buffer).setUint32(1, frame.stream);
+    bytes.set(payload, 5);
+    return bytes;
+}
+export function decodeDirectFrame(bytes) {
+    if (bytes.length < 5)
+        return undefined;
+    const stream = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(1);
+    const payload = bytes.subarray(5);
+    if (bytes[0] === DATA)
+        return { type: "data", stream, data: payload };
+    if (bytes[0] === CLOSE)
+        return { type: "close", stream, error: payload.length ? new TextDecoder().decode(payload) : undefined };
+    return undefined;
+}
+//# sourceMappingURL=direct.js.map

package/dist/direct.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"direct.js","sourceRoot":"","sources":["../src/direct.ts"],"names":[],"mappings":"AAAA,2EAA2E;AAC3E,8EAA8E;AAC9E,uEAAuE;AACvE,+EAA+E;AAC/E,2EAA2E;AAC3E,0EAA0E;AAE1E,uCAAuC;AACvC,MAAM,CAAC,MAAM,YAAY,GAAG,gBAAgB,CAAC;AAE7C,gFAAgF;AAChF,MAAM,CAAC,MAAM,YAAY,GAAG,EAAE,GAAG,IAAI,CAAC;AAEtC;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,+BAA+B,EAAE,kCAAkC,EAAE,8BAA8B,CAAC,CAAC;AAOzI,MAAM,IAAI,GAAG,CAAC,CAAC;AACf,MAAM,KAAK,GAAG,CAAC,CAAC;AAEhB,MAAM,UAAU,iBAAiB,CAAC,KAAkB;IAClD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC;IACjG,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACjD,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;IAChD,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACtD,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IACtB,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,KAAiB;IACjD,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IACvC,MAAM,MAAM,GAAG,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAC3F,MAAM,OAAO,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IAClC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC;IACtE,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,KAAK;QAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;IAChI,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/index.d.ts

@@ -6,3 +6,4 @@ export * from "./shell.js";
 export * from "./crypto.js";
 export * from "./relay.js";
 export * from "./relay-client.js";
+export * from "./direct.js";

package/dist/index.js

@@ -6,4 +6,5 @@ export * from "./shell.js";
 export * from "./crypto.js";
 export * from "./relay.js";
 export * from "./relay-client.js";
+export * from "./direct.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC"}

package/dist/model.d.ts

@@ -17,6 +17,12 @@ export declare const agentCapabilitiesSchema: z.ZodObject<{
     steer: z.ZodBoolean;
     permissions: z.ZodBoolean;
     images: z.ZodBoolean;
+    /**
+     * The agent forks sessions itself, keeping everything it knew. Every agent's
+     * sessions can be forked: without this (or from a single reply, where the
+     * agent only forks whole sessions) LinkShell makes the fork — the new session
+     * shows the conversation and its agent is told it as text.
+     */
     fork: z.ZodBoolean;
     models: z.ZodBoolean;
     modes: z.ZodBoolean;
@@ -88,6 +94,12 @@ export declare const agentInfoSchema: z.ZodObject<{
         steer: z.ZodBoolean;
         permissions: z.ZodBoolean;
         images: z.ZodBoolean;
+        /**
+         * The agent forks sessions itself, keeping everything it knew. Every agent's
+         * sessions can be forked: without this (or from a single reply, where the
+         * agent only forks whole sessions) LinkShell makes the fork — the new session
+         * shows the conversation and its agent is told it as text.
+         */
         fork: z.ZodBoolean;
         models: z.ZodBoolean;
         modes: z.ZodBoolean;
@@ -192,6 +204,80 @@ export declare const sessionActivitySchema: z.ZodObject<{
 }>;
 export type SessionActivity = z.infer<typeof sessionActivitySchema>;
 /** The oldest unanswered permission request, so lists can offer approval inline. Live only. */
+/**
+ * Something the agent asks the user rather than asks permission for: a choice
+ * among options, several of them, or something to type (Claude's
+ * AskUserQuestion, Codex's request_user_input, an MCP server's form).
+ */
+export declare const questionSchema: z.ZodObject<{
+    id: z.ZodString;
+    /** A short label for the question ("Auth method"). */
+    header: z.ZodOptional<z.ZodString>;
+    text: z.ZodString;
+    /** `choice`: one of `options`; `choices`: any number of them; `text`: typed. */
+    kind: z.ZodEnum<["choice", "choices", "text"]>;
+    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        label: string;
+        description?: string | undefined;
+    }, {
+        value: string;
+        label: string;
+        description?: string | undefined;
+    }>, "many">>;
+    /** With options: an answer of the user's own can be typed instead of, or beside, a pick. */
+    other: z.ZodOptional<z.ZodBoolean>;
+    /** What is typed shouldn't be shown (a token). */
+    secret: z.ZodOptional<z.ZodBoolean>;
+    required: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    kind: "text" | "choice" | "choices";
+    text: string;
+    options?: {
+        value: string;
+        label: string;
+        description?: string | undefined;
+    }[] | undefined;
+    other?: boolean | undefined;
+    header?: string | undefined;
+    secret?: boolean | undefined;
+    required?: boolean | undefined;
+}, {
+    id: string;
+    kind: "text" | "choice" | "choices";
+    text: string;
+    options?: {
+        value: string;
+        label: string;
+        description?: string | undefined;
+    }[] | undefined;
+    other?: boolean | undefined;
+    header?: string | undefined;
+    secret?: boolean | undefined;
+    required?: boolean | undefined;
+}>;
+export type Question = z.infer<typeof questionSchema>;
+export declare const questionAnswerSchema: z.ZodObject<{
+    id: z.ZodString;
+    /** The values picked (`choice`: at most one), or what was typed for a `text` question. */
+    values: z.ZodArray<z.ZodString, "many">;
+    /** The user's own answer beside the options. */
+    other: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    values: string[];
+    id: string;
+    other?: string | undefined;
+}, {
+    values: string[];
+    id: string;
+    other?: string | undefined;
+}>;
+export type QuestionAnswer = z.infer<typeof questionAnswerSchema>;
 export declare const pendingPermissionSchema: z.ZodObject<{
     requestId: z.ZodString;
     toolCallId: z.ZodOptional<z.ZodString>;
@@ -210,6 +296,59 @@ export declare const pendingPermissionSchema: z.ZodObject<{
         name: string;
         kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
     }>, "many">;
+    /** Set when this is a question to answer (`sessions.answer`) rather than a permission to give. */
+    questions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        /** A short label for the question ("Auth method"). */
+        header: z.ZodOptional<z.ZodString>;
+        text: z.ZodString;
+        /** `choice`: one of `options`; `choices`: any number of them; `text`: typed. */
+        kind: z.ZodEnum<["choice", "choices", "text"]>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }, {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }>, "many">>;
+        /** With options: an answer of the user's own can be typed instead of, or beside, a pick. */
+        other: z.ZodOptional<z.ZodBoolean>;
+        /** What is typed shouldn't be shown (a token). */
+        secret: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        kind: "text" | "choice" | "choices";
+        text: string;
+        options?: {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }[] | undefined;
+        other?: boolean | undefined;
+        header?: string | undefined;
+        secret?: boolean | undefined;
+        required?: boolean | undefined;
+    }, {
+        id: string;
+        kind: "text" | "choice" | "choices";
+        text: string;
+        options?: {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }[] | undefined;
+        other?: boolean | undefined;
+        header?: string | undefined;
+        secret?: boolean | undefined;
+        required?: boolean | undefined;
+    }>, "many">>;
 }, "strip", z.ZodTypeAny, {
     options: {
         optionId: string;
@@ -220,6 +359,20 @@ export declare const pendingPermissionSchema: z.ZodObject<{
     requestId: string;
     toolCallId?: string | undefined;
     detail?: string | undefined;
+    questions?: {
+        id: string;
+        kind: "text" | "choice" | "choices";
+        text: string;
+        options?: {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }[] | undefined;
+        other?: boolean | undefined;
+        header?: string | undefined;
+        secret?: boolean | undefined;
+        required?: boolean | undefined;
+    }[] | undefined;
 }, {
     options: {
         optionId: string;
@@ -230,6 +383,20 @@ export declare const pendingPermissionSchema: z.ZodObject<{
     requestId: string;
     toolCallId?: string | undefined;
     detail?: string | undefined;
+    questions?: {
+        id: string;
+        kind: "text" | "choice" | "choices";
+        text: string;
+        options?: {
+            value: string;
+            label: string;
+            description?: string | undefined;
+        }[] | undefined;
+        other?: boolean | undefined;
+        header?: string | undefined;
+        secret?: boolean | undefined;
+        required?: boolean | undefined;
+    }[] | undefined;
 }>;
 export type PendingPermissionSummary = z.infer<typeof pendingPermissionSchema>;
 export declare const queuedMessageSchema: z.ZodObject<{
@@ -239,12 +406,12 @@ export declare const queuedMessageSchema: z.ZodObject<{
     images: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     images: number;
-    clientMessageId: string;
     text: string;
+    clientMessageId: string;
 }, {
     images: number;
-    clientMessageId: string;
     text: string;
+    clientMessageId: string;
 }>;
 export type QueuedMessage = z.infer<typeof queuedMessageSchema>;
 /** A sub-agent a session started: the tool call it runs under, and how it is doing. */
@@ -323,6 +490,59 @@ export declare const sessionSummarySchema: z.ZodObject<{
             name: string;
             kind: "allow_once" | "allow_always" | "reject_once" | "reject_always";
         }>, "many">;
+        /** Set when this is a question to answer (`sessions.answer`) rather than a permission to give. */
+        questions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            /** A short label for the question ("Auth method"). */
+            header: z.ZodOptional<z.ZodString>;
+            text: z.ZodString;
+            /** `choice`: one of `options`; `choices`: any number of them; `text`: typed. */
+            kind: z.ZodEnum<["choice", "choices", "text"]>;
+            options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                value: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }, {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }>, "many">>;
+            /** With options: an answer of the user's own can be typed instead of, or beside, a pick. */
+            other: z.ZodOptional<z.ZodBoolean>;
+            /** What is typed shouldn't be shown (a token). */
+            secret: z.ZodOptional<z.ZodBoolean>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            kind: "text" | "choice" | "choices";
+            text: string;
+            options?: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            other?: boolean | undefined;
+            header?: string | undefined;
+            secret?: boolean | undefined;
+            required?: boolean | undefined;
+        }, {
+            id: string;
+            kind: "text" | "choice" | "choices";
+            text: string;
+            options?: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            other?: boolean | undefined;
+            header?: string | undefined;
+            secret?: boolean | undefined;
+            required?: boolean | undefined;
+        }>, "many">>;
     }, "strip", z.ZodTypeAny, {
         options: {
             optionId: string;
@@ -333,6 +553,20 @@ export declare const sessionSummarySchema: z.ZodObject<{
         requestId: string;
         toolCallId?: string | undefined;
         detail?: string | undefined;
+        questions?: {
+            id: string;
+            kind: "text" | "choice" | "choices";
+            text: string;
+            options?: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            other?: boolean | undefined;
+            header?: string | undefined;
+            secret?: boolean | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
     }, {
         options: {
             optionId: string;
@@ -343,6 +577,20 @@ export declare const sessionSummarySchema: z.ZodObject<{
         requestId: string;
         toolCallId?: string | undefined;
         detail?: string | undefined;
+        questions?: {
+            id: string;
+            kind: "text" | "choice" | "choices";
+            text: string;
+            options?: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            other?: boolean | undefined;
+            header?: string | undefined;
+            secret?: boolean | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
     }>>;
     /**
      * Live only: messages waiting for the current turn to end, when the host
@@ -355,13 +603,29 @@ export declare const sessionSummarySchema: z.ZodObject<{
         images: z.ZodNumber;
     }, "strip", z.ZodTypeAny, {
         images: number;
-        clientMessageId: string;
         text: string;
+        clientMessageId: string;
     }, {
         images: number;
-        clientMessageId: string;
         text: string;
+        clientMessageId: string;
     }>, "many">>;
+    /**
+     * The session works in a git worktree LinkShell made for it: its own
+     * checkout and branch, so it can't disturb the project's working directory.
+     * `cwd` is inside the worktree; `source` is the directory it was made from
+     * (the project the session belongs to).
+     */
+    worktree: z.ZodOptional<z.ZodObject<{
+        branch: z.ZodString;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        branch: string;
+        source: string;
+    }, {
+        branch: string;
+        source: string;
+    }>>;
     /** Live only, for sessions that started sub-agents: how many, and how many are working now (`sessions.subagents` lists them). */
     subagents: z.ZodOptional<z.ZodObject<{
         total: z.ZodNumber;
@@ -403,12 +667,30 @@ export declare const sessionSummarySchema: z.ZodObject<{
         requestId: string;
         toolCallId?: string | undefined;
         detail?: string | undefined;
+        questions?: {
+            id: string;
+            kind: "text" | "choice" | "choices";
+            text: string;
+            options?: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            other?: boolean | undefined;
+            header?: string | undefined;
+            secret?: boolean | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
     } | undefined;
     queue?: {
         images: number;
-        clientMessageId: string;
         text: string;
+        clientMessageId: string;
     }[] | undefined;
+    worktree?: {
+        branch: string;
+        source: string;
+    } | undefined;
     subagents?: {
         running: number;
         total: number;
@@ -443,12 +725,30 @@ export declare const sessionSummarySchema: z.ZodObject<{
         requestId: string;
         toolCallId?: string | undefined;
         detail?: string | undefined;
+        questions?: {
+            id: string;
+            kind: "text" | "choice" | "choices";
+            text: string;
+            options?: {
+                value: string;
+                label: string;
+                description?: string | undefined;
+            }[] | undefined;
+            other?: boolean | undefined;
+            header?: string | undefined;
+            secret?: boolean | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
     } | undefined;
     queue?: {
         images: number;
-        clientMessageId: string;
         text: string;
+        clientMessageId: string;
     }[] | undefined;
+    worktree?: {
+        branch: string;
+        source: string;
+    } | undefined;
     subagents?: {
         running: number;
         total: number;
@@ -460,21 +760,79 @@ export declare function parseSessionId(id: string): {
     agent: string;
     nativeId: string;
 } | null;
+/** What git says about a directory, to offer starting a session in a worktree of it. */
+export declare const gitInfoSchema: z.ZodObject<{
+    /** The repository's top directory. */
+    root: z.ZodString;
+    /** The branch checked out; absent on a detached HEAD. */
+    branch: z.ZodOptional<z.ZodString>;
+    /** The commit checked out, abbreviated; absent before the first commit. */
+    head: z.ZodOptional<z.ZodString>;
+    /** Uncommitted changes in the working directory (a new worktree starts from the last commit, without them). */
+    dirty: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    dirty: boolean;
+    root: string;
+    branch?: string | undefined;
+    head?: string | undefined;
+}, {
+    dirty: boolean;
+    root: string;
+    branch?: string | undefined;
+    head?: string | undefined;
+}>;
+export type GitInfo = z.infer<typeof gitInfoSchema>;
+/** A worktree LinkShell made for sessions. */
+export declare const worktreeEntrySchema: z.ZodObject<{
+    /** The worktree's top directory. */
+    path: z.ZodString;
+    branch: z.ZodString;
+    /** The repository it belongs to. */
+    source: z.ZodString;
+    createdAt: z.ZodNumber;
+    /** Sessions working in it. */
+    sessions: z.ZodArray<z.ZodString, "many">;
+    /** Uncommitted changes in it. */
+    dirty: z.ZodBoolean;
+    /** Commits made in it since it was created. */
+    ahead: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    dirty: boolean;
+    path: string;
+    createdAt: number;
+    branch: string;
+    source: string;
+    sessions: string[];
+    ahead: number;
+}, {
+    dirty: boolean;
+    path: string;
+    createdAt: number;
+    branch: string;
+    source: string;
+    sessions: string[];
+    ahead: number;
+}>;
+export type WorktreeEntry = z.infer<typeof worktreeEntrySchema>;
 export declare const projectSummarySchema: z.ZodObject<{
     cwd: z.ZodString;
     name: z.ZodString;
     lastActiveAt: z.ZodNumber;
     sessionCount: z.ZodNumber;
+    /** For a git repository: the branch checked out there now (or the abbreviated commit, on a detached HEAD). */
+    branch: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     cwd: string;
     lastActiveAt: number;
     sessionCount: number;
+    branch?: string | undefined;
 }, {
     name: string;
     cwd: string;
     lastActiveAt: number;
     sessionCount: number;
+    branch?: string | undefined;
 }>;
 export type ProjectSummary = z.infer<typeof projectSummarySchema>;
 export declare const machineInfoSchema: z.ZodObject<{
@@ -513,6 +871,12 @@ export declare const machineInfoSchema: z.ZodObject<{
             steer: z.ZodBoolean;
             permissions: z.ZodBoolean;
             images: z.ZodBoolean;
+            /**
+             * The agent forks sessions itself, keeping everything it knew. Every agent's
+             * sessions can be forked: without this (or from a single reply, where the
+             * agent only forks whole sessions) LinkShell makes the fork — the new session
+             * shows the conversation and its agent is told it as text.
+             */
             fork: z.ZodBoolean;
             models: z.ZodBoolean;
             modes: z.ZodBoolean;
@@ -576,6 +940,17 @@ export declare const machineInfoSchema: z.ZodObject<{
             hint?: string | undefined;
         } | undefined;
     }>, "many">;
+    /**
+     * The host can send bulk streams peer to peer (`direct.offer`); `iceServers`
+     * are the STUN servers both sides use to find a path.
+     */
+    direct: z.ZodOptional<z.ZodObject<{
+        iceServers: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        iceServers: string[];
+    }, {
+        iceServers: string[];
+    }>>;
 }, "strip", z.ZodTypeAny, {
     machineId: string;
     hostname: string;
@@ -604,6 +979,9 @@ export declare const machineInfoSchema: z.ZodObject<{
         } | undefined;
     }[];
     home?: string | undefined;
+    direct?: {
+        iceServers: string[];
+    } | undefined;
 }, {
     machineId: string;
     hostname: string;
@@ -632,6 +1010,9 @@ export declare const machineInfoSchema: z.ZodObject<{
         } | undefined;
     }[];
     home?: string | undefined;
+    direct?: {
+        iceServers: string[];
+    } | undefined;
 }>;
 export type MachineInfo = z.infer<typeof machineInfoSchema>;
 /** A server listening on the host, which a device can preview through the encrypted channel. */