@otto-code/client 0.7.5 → 0.7.6

package/dist/daemon-client-relay-e2ee-transport.js

@@ -1,5 +1,5 @@
 import { createClientChannel, } from "@otto-code/relay/e2ee";
-import { extractRelayMessageData, normalizeTransportPayload, } from "./daemon-client-transport-utils.js";
+import { extractRelayMessage, normalizeTransportPayload } from "./daemon-client-transport-utils.js";
 export function createRelayE2eeTransportFactory(args) {
     return ({ url, headers }) => {
         const base = args.baseFactory({ url, headers });
@@ -38,7 +38,7 @@ export function createEncryptedTransport(base, daemonPublicKeyB64, logger) {
         if (closed) {
             return;
         }
-        emitHandlers(messageHandlers, data);
+        emitHandlers(messageHandlers, data, data instanceof ArrayBuffer);
     };
     const relayTransport = {
         send: (data) => {
@@ -81,8 +81,8 @@ export function createEncryptedTransport(base, daemonPublicKeyB64, logger) {
     base.onOpen(() => {
         void startHandshake();
     });
-    base.onMessage((event) => {
-        relayTransport.onmessage?.(extractRelayMessageData(event));
+    base.onMessage((data, isBinary) => {
+        relayTransport.onmessage?.(extractRelayMessage(data, isBinary));
     });
     base.onClose((event) => {
         const record = event;

package/dist/daemon-client-transport-types.d.ts

@@ -1,7 +1,7 @@
 export interface DaemonTransport {
     send: (data: string | Uint8Array | ArrayBuffer) => void;
     close: (code?: number, reason?: string) => void;
-    onMessage: (handler: (data: unknown) => void) => () => void;
+    onMessage: (handler: (data: unknown, isBinary: boolean) => void) => () => void;
     onOpen: (handler: () => void) => () => void;
     onClose: (handler: (event?: unknown) => void) => () => void;
     onError: (handler: (event?: unknown) => void) => () => void;

package/dist/daemon-client-transport-utils.d.ts

@@ -1,6 +1,10 @@
 export declare function copyArrayBufferViewToBuffer(data: ArrayBufferView): ArrayBuffer;
 export declare function normalizeTransportPayload(data: string | Uint8Array | ArrayBuffer): string | ArrayBuffer;
-export declare function extractRelayMessageData(event: unknown): string | ArrayBuffer;
+export interface RelayTransportMessage {
+    data: string | ArrayBuffer;
+    isBinary: boolean;
+}
+export declare function extractRelayMessage(event: unknown, nodeIsBinary?: boolean): RelayTransportMessage;
 export declare function describeTransportClose(event?: unknown): string;
 export declare function describeTransportError(event?: unknown): string;
 export declare function safeRandomId(): string;

package/dist/daemon-client-transport-utils.js

@@ -10,18 +10,20 @@ export function normalizeTransportPayload(data) {
     }
     return copyArrayBufferViewToBuffer(data);
 }
-export function extractRelayMessageData(event) {
+export function extractRelayMessage(event, nodeIsBinary) {
     const raw = event && typeof event === "object" && "data" in event
         ? event.data
         : event;
-    if (typeof raw === "string")
-        return raw;
+    const isBinary = nodeIsBinary ?? typeof raw !== "string";
+    if (!isBinary) {
+        return { data: decodeMessageData(raw) ?? String(raw ?? ""), isBinary: false };
+    }
     if (raw instanceof ArrayBuffer)
-        return raw;
+        return { data: raw, isBinary: true };
     if (ArrayBuffer.isView(raw)) {
-        return copyArrayBufferViewToBuffer(raw);
+        return { data: copyArrayBufferViewToBuffer(raw), isBinary: true };
     }
-    return String(raw ?? "");
+    return { data: String(raw ?? ""), isBinary: true };
 }
 export function describeTransportClose(event) {
     if (!event) {

package/dist/daemon-client-transport.d.ts

@@ -1,5 +1,5 @@
 export type { DaemonTransport, DaemonTransportFactory, TransportLogger, WebSocketFactory, WebSocketLike, } from "./daemon-client-transport-types.js";
-export { decodeMessageData, describeTransportClose, describeTransportError, encodeUtf8String, extractRelayMessageData, normalizeTransportPayload, safeRandomId, } from "./daemon-client-transport-utils.js";
+export { decodeMessageData, describeTransportClose, describeTransportError, encodeUtf8String, extractRelayMessage, normalizeTransportPayload, safeRandomId, } from "./daemon-client-transport-utils.js";
 export { createEncryptedTransport, createRelayE2eeTransportFactory, } from "./daemon-client-relay-e2ee-transport.js";
 export { bindWsHandler, createWebSocketTransportFactory, defaultWebSocketFactory, } from "./daemon-client-websocket-transport.js";
 //# sourceMappingURL=daemon-client-transport.d.ts.map

package/dist/daemon-client-transport.js

@@ -1,4 +1,4 @@
-export { decodeMessageData, describeTransportClose, describeTransportError, encodeUtf8String, extractRelayMessageData, normalizeTransportPayload, safeRandomId, } from "./daemon-client-transport-utils.js";
+export { decodeMessageData, describeTransportClose, describeTransportError, encodeUtf8String, extractRelayMessage, normalizeTransportPayload, safeRandomId, } from "./daemon-client-transport-utils.js";
 export { createEncryptedTransport, createRelayE2eeTransportFactory, } from "./daemon-client-relay-e2ee-transport.js";
 export { bindWsHandler, createWebSocketTransportFactory, defaultWebSocketFactory, } from "./daemon-client-websocket-transport.js";
 //# sourceMappingURL=daemon-client-transport.js.map

package/dist/daemon-client-websocket-transport.js

@@ -1,3 +1,4 @@
+import { extractRelayMessage } from "./daemon-client-transport-utils.js";
 export function defaultWebSocketFactory(url, options) {
     const globalWs = globalThis.WebSocket;
     if (!globalWs) {
@@ -40,10 +41,17 @@ export function createWebSocketTransportFactory(factory) {
             onOpen: (handler) => bindWsHandler(ws, "open", handler),
             onClose: (handler) => bindWsHandler(ws, "close", handler),
             onError: (handler) => bindWsHandler(ws, "error", handler),
-            onMessage: (handler) => bindWsHandler(ws, "message", handler),
+            onMessage: (handler) => bindWsMessageHandler(ws, handler),
         };
     };
 }
+function bindWsMessageHandler(ws, handler) {
+    const listener = (...args) => {
+        const message = extractRelayMessage(args[0], typeof args[1] === "boolean" ? args[1] : undefined);
+        handler(message.data, message.isBinary);
+    };
+    return bindWsHandler(ws, "message", listener);
+}
 function bindTemporaryEarlyCloseErrorHandler(ws) {
     const noop = () => { };
     if (typeof ws.addEventListener === "function") {

package/dist/daemon-client.d.ts

@@ -1,7 +1,9 @@
+import type { AgentAttentionNotificationPayload } from "@otto-code/protocol/agent-attention-notification";
 import type { z } from "zod";
+import type { ProjectGithubCloneProtocol } from "@otto-code/protocol/messages";
 import { type ClientCapability } from "@otto-code/protocol/client-capabilities";
 import { AgentRefreshedStatusPayloadSchema, CheckoutRenameBranchResponseSchema, RenameTerminalResponseSchema, RestartRequestedStatusPayloadSchema, ShutdownRequestedStatusPayloadSchema, DaemonUpdateResponseSchema, type ServerInfoStatusPayload } from "@otto-code/protocol/messages";
-import type { AgentStreamEventPayload, AgentSnapshotPayload, ProjectPlacementPayload, AgentPermissionResolvedMessage, CreateAgentRequestMessage, CreateOttoWorktreeRequest, CodeListFilesResponse, CodeSymbolLocation, CodeDefinitionLocation, CodeDefinitionStatus, CodeRenameApplyStatus, CodeRenameFileOutcome, CodeRenameUndoFile, CodeRenameUndoStatus, CodeHoverRange, CodeRenameEdit, CodeRenameFilePlan, LspLanguageState, LspRunningServer, CodeSolutionGetTreeResponse, CodeSolutionLoadProjectResponse, SolutionFormat, SolutionRef, SolutionTreeFolder, SolutionTreeProject, SolutionProjectNode, SolutionProjectStatus, SolutionPackageReference, FileCreateResult, FileDeleteResult, FileDownloadTokenResponse, FileEntryKind, FileEol, FileRenameResult, FileReplaceFileResult, FileReplaceRequest, FileReplaceResponse, FileSearchResultPayload, FileSearchSummary, FileUploadResponse, FileExplorerResponse, FileWatchEventPayload, FileWriteResult, FileRefineResult, FileRefineDocument, FileRefineReference, FetchAgentTimelineResponseMessage, AgentForkContextResponseMessage, GitSetupOptions, CheckoutStatusResponse, CheckoutCommitResponse, CheckoutGitCommitResponse, CheckoutGitCommitAgentResponse, CheckoutGitRollbackResponse, CheckoutGitFileHistoryResponse, CheckoutGitFileCommitDiffResponse, CheckoutGitFileBlameResponse, CheckoutGitFileOriginResponse, CheckoutGitGetOperationLogResponse, CheckoutMergeResponse, CheckoutMergeFromBaseResponse, CheckoutPullResponse, CheckoutPushResponse, CheckoutRefreshResponse, CheckoutPrCreateResponse, CheckoutPrMergeResponse, CheckoutPrMergeMethod, CheckoutGithubSetAutoMergeResponse, CheckoutGithubGetCheckDetailsResponse, PreviewListConfigResponse, PreviewStartResponse, PreviewBindTabResponse, PreviewStopResponse, CheckoutPrStatusResponse, PullRequestTimelineResponse, CheckoutSwitchBranchResponse, StashSaveResponse, StashPopResponse, StashListResponse, ValidateBranchResponse, BranchSuggestionsResponse, GitHubSearchResponse, GitHubSearchRequest, GitHostingProviderId, HostingSearchRequest, HostingSearchResponse, HostingAuthStatusResponse, DirectorySuggestionsResponse, OttoWorktreeListResponse, OttoWorktreeArchiveResponse, ProjectIconResponse, ContextCategory, ContextPromptPreviewGetResponseMessage, ContextReportGetResponseMessage, ContextEdgeConvertResponseMessage, ContextFindingsFixResponseMessage, PersonalityMemoryListResponseMessage, PersonalityMemoryUpdateResponseMessage, PersonalityMemoryTransferResponseMessage, PersonalityMemoryStatsResponseMessage, ProjectAddResponse, ProjectScaffoldGit, ProjectScaffoldProgress, ProjectScaffoldResponse, HostingListRepositoriesResponse, HostingListOwnersResponse, OpenProjectResponseMessage, ArchiveWorkspaceResponseMessage, WorkspaceArchivePreflightResponse, WorktreeBaseRefSetResponse, WorktreeReattachListResponse, WorktreeReattachResponse, WorktreeReattachTarget, WorkspaceSetupStatusResponseMessage, ListCommandsResponse, ListProviderFeaturesResponseMessage, ListProviderModelsResponseMessage, ListProviderModesResponseMessage, ListAvailableProvidersResponse, GetProvidersSnapshotResponseMessage, RefreshProvidersSnapshotResponseMessage, ProviderDiagnosticResponseMessage, ProviderUsageListResponseMessage, StatsActivityGetResponseMessage, StatsActivityResetResponseMessage, UsageLogGetResponseMessage, AgentContextGetUsageResponseMessage, DaemonGetStatusResponse, DaemonGetPairingOfferResponse, DiagnosticsResponse, AgentRewindResponseMessage, ListTerminalsResponse, CreateTerminalResponse, SubscribeTerminalResponse, SubscribeTerminalRequest, CloseItemsResponse, AttachmentsImagesClearResponse, AttachmentsImagesStatsResponse, HistoryAgentsClearArchivedResponse, KillTerminalResponse, CaptureTerminalResponse, TerminalInput, SessionInboundMessage, SessionOutboundMessage, SendAgentMessageRequest, AgentPromptDelivery, TasksSuggestedStartMode, OttoConfigRaw, OttoConfigRevision, WorkspaceCreateRequest } from "@otto-code/protocol/messages";
+import type { AgentStreamEventPayload, AgentSnapshotPayload, ProjectPlacementPayload, AgentPermissionResolvedMessage, CreateAgentRequestMessage, CreateOttoWorktreeRequest, CodeListFilesResponse, CodeSymbolLocation, CodeDefinitionLocation, CodeDefinitionStatus, CodeRenameApplyStatus, CodeRenameFileOutcome, CodeRenameUndoFile, CodeRenameUndoStatus, CodeHoverRange, CodeRenameEdit, CodeRenameFilePlan, LspLanguageState, LspRunningServer, CodeSolutionGetTreeResponse, CodeSolutionLoadProjectResponse, SolutionFormat, SolutionRef, SolutionTreeFolder, SolutionTreeProject, SolutionProjectNode, SolutionProjectStatus, SolutionPackageReference, FileCreateResult, FileDeleteResult, FileDownloadTokenResponse, FileEntryKind, FileEol, FileRenameResult, FileReplaceFileResult, FileReplaceRequest, FileReplaceResponse, FileSearchResultPayload, FileSearchSummary, FileUploadResponse, FileExplorerResponse, FileWatchEventPayload, FileWriteResult, FileRefineResult, FileRefineDocument, FileRefineReference, FetchAgentTimelineResponseMessage, AgentForkContextResponseMessage, GitSetupOptions, CheckoutStatusResponse, CheckoutCommitResponse, CheckoutGitCommitResponse, CheckoutGitCommitAgentResponse, CheckoutGitRollbackResponse, CheckoutGitFileHistoryResponse, CheckoutGitFileCommitDiffResponse, CheckoutGitFileBlameResponse, CheckoutGitFileOriginResponse, CheckoutGitGetOperationLogResponse, CheckoutMergeResponse, CheckoutMergeFromBaseResponse, CheckoutPullResponse, CheckoutPushResponse, CheckoutRefreshResponse, CheckoutPrCreateResponse, CheckoutPrMergeResponse, CheckoutPrMergeMethod, CheckoutGithubSetAutoMergeResponse, CheckoutGithubGetCheckDetailsResponse, PreviewListConfigResponse, PreviewStartResponse, PreviewBindTabResponse, PreviewStopResponse, CheckoutPrStatusResponse, PullRequestTimelineResponse, CheckoutSwitchBranchResponse, StashSaveResponse, StashPopResponse, StashListResponse, ValidateBranchResponse, BranchSuggestionsResponse, FileVersion, CheckoutCommit, ParsedDiffFile, WorkspaceRecoveryState, CheckoutForgeGetCheckDetailsResponse, CheckoutForgeSetAutoMergeResponse, ProjectCreateDirectoryResponse, FsFileWriteResult, FsFileWriteBinaryResult, GitHubSearchResponse, GitHubSearchRequest, ForgeSearchResponse, ForgeSearchRequest, GitHostingProviderId, HostingSearchRequest, HostingSearchResponse, HostingAuthStatusResponse, DirectorySuggestionsResponse, OttoWorktreeListResponse, OttoWorktreeArchiveResponse, ProjectIconResponse, ContextCategory, ContextPromptPreviewGetResponseMessage, ContextReportGetResponseMessage, ContextEdgeConvertResponseMessage, ContextFindingsFixResponseMessage, PersonalityMemoryListResponseMessage, PersonalityMemoryUpdateResponseMessage, PersonalityMemoryTransferResponseMessage, PersonalityMemoryStatsResponseMessage, ProjectAddResponse, ProjectScaffoldGit, ProjectScaffoldProgress, ProjectScaffoldResponse, HostingListRepositoriesResponse, HostingListOwnersResponse, OpenProjectResponseMessage, ArchiveWorkspaceResponseMessage, WorkspaceArchivePreflightResponse, WorktreeBaseRefSetResponse, WorktreeReattachListResponse, WorktreeReattachResponse, WorktreeReattachTarget, WorkspaceSetupStatusResponseMessage, ListCommandsResponse, ListProviderFeaturesResponseMessage, ListProviderModelsResponseMessage, ListProviderModesResponseMessage, ListAvailableProvidersResponse, GetProvidersSnapshotResponseMessage, RefreshProvidersSnapshotResponseMessage, ProviderDiagnosticResponseMessage, ProviderUsageListResponseMessage, StatsActivityGetResponseMessage, StatsActivityResetResponseMessage, UsageLogGetResponseMessage, AgentContextGetUsageResponseMessage, DaemonGetStatusResponse, DaemonGetPairingOfferResponse, DiagnosticsResponse, AgentRewindResponseMessage, ListTerminalsResponse, CreateTerminalResponse, SubscribeTerminalResponse, SubscribeTerminalRequest, CloseItemsResponse, AttachmentsImagesClearResponse, AttachmentsImagesStatsResponse, HistoryAgentsClearArchivedResponse, KillTerminalResponse, CaptureTerminalResponse, TerminalInput, SessionInboundMessage, SessionOutboundMessage, SendAgentMessageRequest, AgentPromptDelivery, TasksSuggestedStartMode, OttoConfigRaw, OttoConfigRevision, WorkspaceCreateRequest } from "@otto-code/protocol/messages";
 import type { AgentPermissionRequest, AgentPermissionResponse, AgentPersistenceHandle, AgentProviderNotice, AgentProvider, AgentSessionConfig } from "@otto-code/protocol/agent-types";
 import type { OrchestrationGraph, PromptTemplate, Run } from "@otto-code/protocol/orchestration";
 import type { BrainCatalogModel, BrainEvals, BrainHfSearchResult, BrainHostStatus, BrainInstalledModel, BrainJob, BrainNetworkInfo, BrainRemoteConfig, BrainRepoQuant, BrainRuntime, ConnectorsListToolsResponse, CueMoment, MutableDaemonConfig, MutableDaemonConfigPatch, ProjectLink, SpeechSettingsOptions, SpeechTtsPreviewResult, SpeechTtsSpeakResult, SpeechTtsSpeakCancelResult, VisualizerVoiceCuesResult, AgentPersonalitiesGenerateProfileResult } from "@otto-code/protocol/messages";
@@ -156,6 +158,12 @@ export interface CreateAgentRequestOptions extends AgentConfigOverrides {
     personality?: CreateAgentRequestMessage["personality"];
     env?: CreateAgentRequestMessage["env"];
     workspaceId?: string;
+    /**
+     * Caller agent making this request. The daemon resolves the caller's own
+     * workspace and parentage from it, so a managed CLI run nests under its
+     * parent exactly as agent-scoped MCP creation does.
+     */
+    callerAgentId?: string;
     initialPrompt?: string;
     clientMessageId?: string;
     outputSchema?: Record<string, unknown>;
@@ -168,7 +176,7 @@ export interface CreateAgentRequestOptions extends AgentConfigOverrides {
     requestId?: string;
     labels?: Record<string, string>;
 }
-export interface CreateOttoWorktreeInput extends Pick<CreateOttoWorktreeRequest, "cwd" | "projectId" | "worktreeSlug" | "firstAgentContext" | "refName" | "action" | "githubPrNumber"> {
+export interface CreateOttoWorktreeInput extends Pick<CreateOttoWorktreeRequest, "cwd" | "projectId" | "worktreeSlug" | "firstAgentContext" | "refName" | "action" | "githubPrNumber" | "checkoutSource"> {
 }
 type CheckoutStatusPayload = CheckoutStatusResponse["payload"];
 type SubscribeCheckoutDiffPayload = Extract<SessionOutboundMessage, {
@@ -207,6 +215,23 @@ type StashListPayload = StashListResponse["payload"];
 type ValidateBranchPayload = ValidateBranchResponse["payload"];
 type BranchSuggestionsPayload = BranchSuggestionsResponse["payload"];
 type GitHubSearchPayload = GitHubSearchResponse["payload"];
+type CheckoutForgeGetCheckDetailsPayload = CheckoutForgeGetCheckDetailsResponse["payload"];
+type CheckoutForgeSetAutoMergePayload = CheckoutForgeSetAutoMergeResponse["payload"];
+export type ProjectCreateDirectoryPayload = ProjectCreateDirectoryResponse["payload"];
+export type ProjectListPayload = Extract<SessionOutboundMessage, {
+    type: "project.list.response";
+}>["payload"];
+export type WorkspaceGithubSearchRepositoriesPayload = Extract<SessionOutboundMessage, {
+    type: "workspace.github.search_repositories.response";
+}>["payload"];
+export interface AgentAttentionRequiredNotification {
+    agentId: string;
+    reason: "finished" | "error" | "permission";
+    timestamp: string;
+    shouldNotify: boolean;
+    notification?: AgentAttentionNotificationPayload;
+}
+type ForgeSearchPayload = ForgeSearchResponse["payload"];
 export type HostingSearchPayload = HostingSearchResponse["payload"];
 export type HostingAuthStatusPayload = HostingAuthStatusResponse["payload"];
 type DirectorySuggestionsPayload = DirectorySuggestionsResponse["payload"];
@@ -234,6 +259,8 @@ export interface FileReadResult {
      * daemons older than v0.4.4. Absent means "not reported", not "LF".
      */
     eol?: FileEol;
+    /** Opaque version tag for optimistic-concurrency writes; same caveat as eol. */
+    revision?: string;
 }
 export interface TextFileReadResult {
     path: string;
@@ -254,6 +281,23 @@ export interface FileWriteOptions {
     eol?: FileEol;
     requestId?: string;
 }
+/**
+ * Bytes to a workspace path. Gated on `features.binaryFileWrite`. Unlike
+ * {@link FileWriteOptions} this carries no precondition: `overwrite` is the
+ * whole policy — see `FsFileWriteBinaryRequestSchema` for why a generated
+ * artifact has nothing to reconcile against.
+ */
+export interface FileWriteBinaryOptions {
+    cwd: string;
+    /** Workspace-relative, like every other file RPC. */
+    path: string;
+    /** Sent as file-transfer frames, not inside the request. */
+    bytes: Uint8Array | ArrayBuffer;
+    overwrite?: boolean;
+    requestId?: string;
+    /** Frame size, for tests that want to observe chunking. Defaults to 1 MB. */
+    chunkSize?: number;
+}
 /**
  * The general file-mutation surface — what exists in a directory, rather than
  * what is inside a file. Gated on `features.fileMutations`; there is no
@@ -541,7 +585,21 @@ export interface FetchAgentTimelineOptions {
     requestId?: string;
     timeout?: number;
 }
+export type ProviderSubagentListPayload = Extract<SessionOutboundMessage, {
+    type: "agent.provider_subagents.list.response";
+}>["payload"];
+export type ProviderSubagentTimelinePayload = Extract<SessionOutboundMessage, {
+    type: "agent.provider_subagents.timeline.get.response";
+}>["payload"];
+export interface FetchProviderSubagentTimelineOptions {
+    direction?: ProviderSubagentTimelinePayload["direction"];
+    cursor?: FetchAgentTimelineCursor;
+    limit?: number;
+    requestId?: string;
+    timeout?: number;
+}
 export interface AgentForkContextOptions {
+    boundaryCursor?: FetchAgentTimelineCursor;
     boundaryMessageId?: string;
     requestId?: string;
 }
@@ -779,6 +837,9 @@ export interface WaitForFinishResult {
     error: string | null;
     lastMessage: string | null;
 }
+type ProjectGithubClonePayload = Extract<SessionOutboundMessage, {
+    type: "project.github.clone.response";
+}>["payload"];
 export declare class DaemonClient {
     private config;
     private transport;
@@ -801,6 +862,7 @@ export declare class DaemonClient {
     private connectionState;
     private checkoutDiffSubscriptions;
     private terminalDirectorySubscriptions;
+    private fileSubscriptions;
     private readonly terminalStreams;
     private readonly scaffoldProgressListeners;
     private pendingBinaryFileReads;
@@ -1091,6 +1153,55 @@ export declare class DaemonClient {
     resumeAgent(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>): Promise<AgentSnapshotPayload>;
     importAgent(input: ImportAgentInput): Promise<AgentSnapshotPayload>;
     refreshAgent(agentId: string, requestId?: string): Promise<AgentRefreshedStatusPayload>;
+    listProviderSubagents(parentAgentId: string, options?: {
+        requestId?: string;
+        timeout?: number;
+    }): Promise<ProviderSubagentListPayload>;
+    fetchProviderSubagentTimeline(parentAgentId: string, subagentId: string, options?: FetchProviderSubagentTimelineOptions): Promise<ProviderSubagentTimelinePayload>;
+    checkoutForgeGetCheckDetails(input: {
+        cwd: string;
+        repoOwner?: string;
+        repoName?: string;
+        checkRunId?: number;
+        workflowRunId?: number;
+        changeRequestNumber?: number;
+    }, requestId?: string): Promise<CheckoutForgeGetCheckDetailsPayload>;
+    checkoutForgeSetAutoMerge(cwd: string, input: {
+        enabled: true;
+        method: CheckoutPrMergeMethod;
+    } | {
+        enabled: false;
+    }, requestId?: string): Promise<CheckoutForgeSetAutoMergePayload>;
+    createProjectDirectory(input: {
+        parentPath: string;
+        name: string;
+    }, requestId?: string): Promise<ProjectCreateDirectoryPayload>;
+    getCommitFileDiff(cwd: string, sha: string, path: string, requestId?: string): Promise<{
+        file: ParsedDiffFile | null;
+    }>;
+    inspectWorkspaceRecovery(workspaceId: string, requestId?: string): Promise<WorkspaceRecoveryState>;
+    listCheckoutCommits(cwd: string, requestId?: string): Promise<{
+        baseRef: string | null;
+        commits: CheckoutCommit[];
+    }>;
+    listProjects(requestId?: string): Promise<ProjectListPayload>;
+    onAgentAttentionRequired(handler: (notification: AgentAttentionRequiredNotification) => void): () => void;
+    restoreWorkspace(workspaceId: string, requestId?: string): Promise<void>;
+    searchGithubRepositories(input: {
+        query: string;
+        limit?: number;
+    }, requestId?: string): Promise<WorkspaceGithubSearchRepositoriesPayload>;
+    setAgentTimelineSubscription(agentIds: string[]): Promise<void>;
+    setWorkspacePinned(workspaceId: string, pinned: boolean, requestId?: string): Promise<{
+        pinnedAt: string | null;
+    }>;
+    subscribeFile(input: {
+        cwd: string;
+        path: string;
+    }, onUpdate: (version: FileVersion) => void): Promise<{
+        initial: FileVersion;
+        unsubscribe: () => void;
+    }>;
     fetchAgentTimeline(agentId: string, options?: FetchAgentTimelineOptions): Promise<FetchAgentTimelinePayload>;
     buildAgentForkContext(agentId: string, options?: AgentForkContextOptions): Promise<AgentForkContextPayload>;
     sendAgentMessage(agentId: string, text: string, options?: SendMessageOptions): Promise<SendAgentMessageResult>;
@@ -1118,7 +1229,7 @@ export declare class DaemonClient {
         cancelled?: boolean;
     }>;
     setAgentMode(agentId: string, modeId: string): Promise<AgentProviderNotice | null>;
-    setAgentModel(agentId: string, modelId: string | null): Promise<void>;
+    setAgentModel(agentId: string, modelId: string | null): Promise<AgentProviderNotice | null>;
     setAgentFeature(agentId: string, featureId: string, value: unknown): Promise<void>;
     setAgentThinkingOption(agentId: string, thinkingOptionId: string | null): Promise<AgentProviderNotice | null>;
     /**
@@ -1276,6 +1387,12 @@ export declare class DaemonClient {
         query?: string;
         limit?: number;
     }, requestId?: string): Promise<BranchSuggestionsPayload>;
+    searchForge(options: {
+        cwd: string;
+        query: string;
+        limit?: number;
+        kinds?: ForgeSearchRequest["kinds"];
+    }, requestId?: string): Promise<ForgeSearchPayload>;
     searchGitHub(options: {
         cwd: string;
         query: string;
@@ -1307,8 +1424,36 @@ export declare class DaemonClient {
      * save-precondition baseline (modifiedAt, eol, hash) alongside the content.
      */
     readTextFile(cwd: string, path: string, requestId?: string): Promise<TextFileReadResult>;
+    /**
+     * The fs.file.write RPC: optimistic-concurrency writes keyed by an opaque
+     * revision. The hash-keyed `writeFile` below is kept for callers
+     * that have not moved over.
+     */
+    writeFsFile(input: {
+        cwd: string;
+        path: string;
+        content: string;
+        expectedModifiedAt: string;
+        expectedRevision?: string;
+    }): Promise<FsFileWriteResult>;
     /** Conditional save — see FileWriteRequestSchema for the no-clobber contract. */
     writeFile(options: FileWriteOptions): Promise<FileWriteResult>;
+    /**
+     * Write bytes to a workspace file — the path for generated artifacts the
+     * text write cannot carry (it refuses binary targets outright). Gated on
+     * `features.binaryFileWrite`; there is no client-side substitute, because
+     * the client never touches a workspace file on any platform.
+     *
+     * Shaped like {@link uploadFile}: the JSON request says where the bytes go
+     * and how many to expect, then the bytes follow as file-transfer frames
+     * correlated on the same `requestId`. The daemon answers at FileEnd.
+     */
+    writeBinaryFile(options: FileWriteBinaryOptions): Promise<FsFileWriteBinaryResult>;
+    /**
+     * FileBegin, chunks, FileEnd. Synchronous through `sendBinaryFrame`, so the
+     * frames leave in order and behind the JSON request that announced them.
+     */
+    private sendFileTransfer;
     /** Create an empty file or a directory. Never overwrites — see FileCreateResultSchema. */
     createFileEntry(options: FileCreateOptions): Promise<FileCreateResult>;
     /** Permanent delete — an unlink, not a move to any trash. */
@@ -1775,8 +1920,67 @@ export declare class DaemonClient {
     private recordLivenessFailure;
     private handleSessionMessage;
     private resolveWaiters;
+    private rejectWaitersForRequestId;
     private clearWaiters;
     private toEvent;
     private waitForWithCancel;
+    cloneGithubProject(input: {
+        repo: string;
+        targetDirectory: string;
+        cloneProtocol?: ProjectGithubCloneProtocol;
+    }, requestId?: string): Promise<ProjectGithubClonePayload>;
+    /**
+     * `includeDiscovered` also returns the Scripts the workspace's own project
+     * files declare (package.json scripts today), each tagged with its `source`.
+     * Gate it on `server_info.features.workspaceScriptDiscovery` — an older
+     * daemon ignores the flag and answers with the otto.json list only.
+     */
+    listWorkspaceScripts(workspaceId: string, options?: {
+        includeDiscovered?: boolean;
+        requestId?: string;
+    }): Promise<Extract<SessionOutboundMessage, {
+        type: "workspace.script.list.response";
+    }>["payload"]>;
+    startWorkspaceScriptWithStatus(workspaceId: string, scriptName: string, requestId?: string): Promise<Extract<SessionOutboundMessage, {
+        type: "workspace.script.start.response";
+    }>["payload"]>;
+    stopWorkspaceScript(workspaceId: string, scriptName: string, requestId?: string): Promise<Extract<SessionOutboundMessage, {
+        type: "workspace.script.stop.response";
+    }>["payload"]>;
+    connectHub(hubUrl: string, token: string, requestId?: string): Promise<{
+        requestId: string;
+        status: {
+            state: "connecting" | "connected" | "not_connected" | "reconnecting" | "disconnecting" | "revoked";
+            daemonId: string | null;
+            hubOrigin: string | null;
+            scopes: string[];
+            connectedAt: string | null;
+            lastError: string | null;
+        };
+    }>;
+    getHubStatus(requestId?: string): Promise<{
+        requestId: string;
+        status: {
+            state: "connecting" | "connected" | "not_connected" | "reconnecting" | "disconnecting" | "revoked";
+            daemonId: string | null;
+            hubOrigin: string | null;
+            scopes: string[];
+            connectedAt: string | null;
+            lastError: string | null;
+        };
+    }>;
+    disconnectHub(force?: boolean, requestId?: string): Promise<{
+        requestId: string;
+        status: {
+            state: "connecting" | "connected" | "not_connected" | "reconnecting" | "disconnecting" | "revoked";
+            daemonId: string | null;
+            hubOrigin: string | null;
+            scopes: string[];
+            connectedAt: string | null;
+            lastError: string | null;
+        };
+        warning?: string | undefined;
+    }>;
+    private requireHubRelationshipSupport;
 }
 //# sourceMappingURL=daemon-client.d.ts.map

package/dist/daemon-client.js

@@ -57,6 +57,16 @@ class DaemonRpcError extends Error {
         this.code = params.code;
     }
 }
+class DaemonProtocolError extends Error {
+    constructor(identity) {
+        const responseLabel = identity.responseType ?? "unknown response";
+        super(`Response validation failed for ${responseLabel}`);
+        this.code = "invalid_response";
+        this.name = "DaemonProtocolError";
+        this.requestId = identity.requestId;
+        this.responseType = identity.responseType;
+    }
+}
 class PingTimeoutError extends Error {
     constructor(timeoutMs) {
         super(`Ping timed out (${timeoutMs}ms)`);
@@ -64,6 +74,40 @@ class PingTimeoutError extends Error {
         this.name = "PingTimeoutError";
     }
 }
+/**
+ * Pull the request correlation out of a frame that failed schema validation.
+ * Reads only the envelope and `payload.requestId`, which is exactly the part a
+ * malformed response still gets right, so the waiting caller can be failed with
+ * a real reason rather than left to time out.
+ */
+function extractCorrelatedResponseIdentity(input) {
+    if (!input || typeof input !== "object") {
+        return null;
+    }
+    const envelope = input;
+    if (envelope.type !== "session" || !envelope.message || typeof envelope.message !== "object") {
+        return null;
+    }
+    const message = envelope.message;
+    if (typeof message.type !== "string" ||
+        !(message.type === "rpc_error" ||
+            message.type.endsWith("_response") ||
+            message.type.endsWith(".response") ||
+            message.type.endsWith("/response"))) {
+        return null;
+    }
+    if (!message.payload || typeof message.payload !== "object") {
+        return null;
+    }
+    const payload = message.payload;
+    if (typeof payload.requestId !== "string") {
+        return null;
+    }
+    return {
+        requestId: payload.requestId,
+        responseType: message.type,
+    };
+}
 function toTimeoutError(error, label, timeoutMs) {
     if (error instanceof PingTimeoutError) {
         return new Error(`${label} timed out (${timeoutMs}ms)`);
@@ -120,6 +164,7 @@ function legacyExplorerFileToBytes(file) {
         kind: file.kind,
         modifiedAt: file.modifiedAt,
         eol: file.eol,
+        revision: file.revision,
     };
 }
 function binaryFileKind(mime, encoding) {
@@ -180,6 +225,9 @@ function unwrapBrainJob(payload) {
     }
     return payload.job;
 }
+// A repo clone can take minutes on a large history, so it gets its own budget
+// rather than the default request timeout.
+const PROJECT_GITHUB_CLONE_TIMEOUT_MS = 5 * 60 * 1000;
 export class DaemonClient {
     constructor(config) {
         this.config = config;
@@ -203,6 +251,7 @@ export class DaemonClient {
         this.connectionState = { status: "idle" };
         this.checkoutDiffSubscriptions = new Map();
         this.terminalDirectorySubscriptions = new Map();
+        this.fileSubscriptions = new Map();
         this.terminalStreams = new TerminalStreamRouter();
         // requestId -> progress listener for an in-flight project.scaffold.request.
         // Entries are always removed in scaffoldProject's finally block.
@@ -670,7 +719,7 @@ export class DaemonClient {
                 return null;
             }
             return { kind: "ok", value };
-        }, timeout, params.options);
+        }, timeout, { ...params.options, requestId: params.requestId });
         try {
             await this.sendSessionMessageOrThrow(params.message);
         }
@@ -1276,6 +1325,7 @@ export class DaemonClient {
             ...(options.personality ? { personality: options.personality } : {}),
             ...(options.env ? { env: options.env } : {}),
             ...(options.workspaceId !== undefined ? { workspaceId: options.workspaceId } : {}),
+            ...(options.callerAgentId !== undefined ? { callerAgentId: options.callerAgentId } : {}),
             ...(options.initialPrompt ? { initialPrompt: options.initialPrompt } : {}),
             ...(options.clientMessageId ? { clientMessageId: options.clientMessageId } : {}),
             ...(options.outputSchema ? { outputSchema: options.outputSchema } : {}),
@@ -1853,6 +1903,266 @@ export class DaemonClient {
             },
         });
     }
+    async listProviderSubagents(parentAgentId, options = {}) {
+        const requestId = this.createRequestId(options.requestId);
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.provider_subagents.list.request",
+            parentAgentId,
+            requestId,
+        });
+        const payload = await this.sendRequest({
+            requestId,
+            message,
+            timeout: options.timeout,
+            options: { skipQueue: true },
+            select: (response) => response.type === "agent.provider_subagents.list.response" &&
+                response.payload.requestId === requestId
+                ? response.payload
+                : null,
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload;
+    }
+    async fetchProviderSubagentTimeline(parentAgentId, subagentId, options = {}) {
+        const requestId = this.createRequestId(options.requestId);
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.provider_subagents.timeline.get.request",
+            parentAgentId,
+            subagentId,
+            requestId,
+            ...(options.direction ? { direction: options.direction } : {}),
+            ...(options.cursor ? { cursor: options.cursor } : {}),
+            ...(typeof options.limit === "number" ? { limit: options.limit } : {}),
+        });
+        const payload = await this.sendRequest({
+            requestId,
+            message,
+            timeout: options.timeout,
+            options: { skipQueue: true },
+            select: (response) => response.type === "agent.provider_subagents.timeline.get.response" &&
+                response.payload.requestId === requestId
+                ? response.payload
+                : null,
+        });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return payload;
+    }
+    async checkoutForgeGetCheckDetails(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout.forge.get_check_details.request",
+                cwd: input.cwd,
+                repoOwner: input.repoOwner,
+                repoName: input.repoName,
+                checkRunId: input.checkRunId,
+                workflowRunId: input.workflowRunId,
+                changeRequestNumber: input.changeRequestNumber,
+            },
+            timeout: 60000,
+        });
+    }
+    async checkoutForgeSetAutoMerge(cwd, input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout.forge.set_auto_merge.request",
+                cwd,
+                enabled: input.enabled,
+                ...(input.enabled ? { mergeMethod: input.method } : {}),
+            },
+            timeout: 60000,
+        });
+    }
+    async createProjectDirectory(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "project.create_directory.request",
+                parentPath: input.parentPath,
+                name: input.name,
+            },
+        });
+    }
+    async getCommitFileDiff(cwd, sha, path, requestId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout.commits.file_diff.request",
+                cwd,
+                sha,
+                path,
+            },
+            timeout: 60000,
+        });
+        if (payload.error) {
+            throw new Error(payload.error.message);
+        }
+        return { file: payload.file };
+    }
+    async inspectWorkspaceRecovery(workspaceId, requestId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "workspace.recovery.inspect.request",
+                workspaceId,
+            },
+        });
+        return payload.state;
+    }
+    async listCheckoutCommits(cwd, requestId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "checkout.commits.list.request",
+                cwd,
+            },
+            timeout: 60000,
+        });
+        if (payload.error) {
+            throw new Error(payload.error.message);
+        }
+        return { baseRef: payload.baseRef, commits: payload.commits };
+    }
+    async listProjects(requestId) {
+        const resolvedRequestId = this.createRequestId(requestId);
+        const message = SessionInboundMessageSchema.parse({
+            type: "project.list.request",
+            requestId: resolvedRequestId,
+        });
+        return this.sendRequest({
+            requestId: resolvedRequestId,
+            message,
+            options: { skipQueue: true },
+            select: (msg) => {
+                if (msg.type !== "project.list.response")
+                    return null;
+                if (msg.payload.requestId !== resolvedRequestId)
+                    return null;
+                return msg.payload;
+            },
+        });
+    }
+    onAgentAttentionRequired(handler) {
+        const unsubscribeLegacy = this.on("agent_stream", (message) => {
+            if (message.payload.event.type !== "attention_required") {
+                return;
+            }
+            const event = message.payload.event;
+            handler({
+                agentId: message.payload.agentId,
+                reason: event.reason,
+                timestamp: event.timestamp,
+                shouldNotify: event.shouldNotify,
+                ...(event.notification ? { notification: event.notification } : {}),
+            });
+        });
+        const unsubscribeDedicated = this.on("agent_attention_required", (message) => {
+            handler(message.payload);
+        });
+        return () => {
+            unsubscribeLegacy();
+            unsubscribeDedicated();
+        };
+    }
+    async restoreWorkspace(workspaceId, requestId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "workspace.recovery.restore.request",
+                workspaceId,
+            },
+            timeout: 150000,
+        });
+        if (!payload.accepted) {
+            throw new Error(payload.error ?? "Workspace recovery was rejected by the host");
+        }
+    }
+    async searchGithubRepositories(input, requestId) {
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "workspace.github.search_repositories.request",
+                query: input.query,
+                limit: input.limit,
+            },
+        });
+    }
+    async setAgentTimelineSubscription(agentIds) {
+        // COMPAT(selectiveAgentTimeline): added in v0.1.106. Old daemons keep their
+        // legacy global stream and do not understand this RPC. Remove after
+        // 2027-01-12 once the supported daemon floor is >= v0.1.106.
+        if (!this.lastServerInfoMessage?.features?.selectiveAgentTimeline) {
+            return;
+        }
+        const requestId = this.createRequestId();
+        const normalizedAgentIds = [...new Set(agentIds)].sort();
+        const message = SessionInboundMessageSchema.parse({
+            type: "agent.timeline.set_subscription.request",
+            agentIds: normalizedAgentIds,
+            requestId,
+        });
+        await this.sendRequest({
+            requestId,
+            message,
+            options: { skipQueue: true },
+            select: (response) => {
+                if (response.type !== "agent.timeline.set_subscription.response") {
+                    return null;
+                }
+                return response.payload.requestId === requestId ? response.payload : null;
+            },
+        });
+    }
+    async setWorkspacePinned(workspaceId, pinned, requestId) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "workspace.pin.set.request",
+                workspaceId,
+                pinned,
+            },
+            responseType: "workspace.pin.set.response",
+        });
+        if (!payload.accepted) {
+            throw new Error(payload.error ?? "setWorkspacePinned rejected");
+        }
+        return { pinnedAt: payload.pinnedAt };
+    }
+    async subscribeFile(input, onUpdate) {
+        const subscriptionId = this.createRequestId();
+        this.fileSubscriptions.set(subscriptionId, { ...input, onUpdate });
+        try {
+            const payload = await this.sendCorrelatedSessionRequest({
+                message: {
+                    type: "fs.file.subscribe.request",
+                    cwd: input.cwd,
+                    path: input.path,
+                    subscriptionId,
+                },
+                responseType: "fs.file.subscribe.response",
+            });
+            return {
+                initial: payload.initial,
+                unsubscribe: () => {
+                    if (!this.fileSubscriptions.delete(subscriptionId))
+                        return;
+                    void this.sendCorrelatedSessionRequest({
+                        message: { type: "fs.file.unsubscribe.request", subscriptionId },
+                        responseType: "fs.file.unsubscribe.response",
+                    }).catch(() => undefined);
+                },
+            };
+        }
+        catch (error) {
+            this.fileSubscriptions.delete(subscriptionId);
+            throw error;
+        }
+    }
     async fetchAgentTimeline(agentId, options = {}) {
         const resolvedRequestId = this.createRequestId(options.requestId);
         const message = SessionInboundMessageSchema.parse({
@@ -1890,6 +2200,7 @@ export class DaemonClient {
             type: "agent.fork_context.request",
             agentId,
             requestId: resolvedRequestId,
+            ...(options.boundaryCursor ? { boundaryCursor: options.boundaryCursor } : {}),
             ...(options.boundaryMessageId ? { boundaryMessageId: options.boundaryMessageId } : {}),
         });
         const payload = await this.sendRequest({
@@ -2095,6 +2406,13 @@ export class DaemonClient {
                 return msg.payload;
             },
         });
+        // A refused cancellation comes back as an error payload, not a rejected
+        // frame. Dropping it reported Stop as successful while the provider was
+        // still running and still spending tokens — the exact outcome the daemon
+        // refuses the cancel to avoid.
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
         // Absent ⇒ old daemon that doesn't report whether a run was interrupted.
         return payload.cancelled !== undefined ? { cancelled: payload.cancelled } : {};
     }
@@ -2150,6 +2468,7 @@ export class DaemonClient {
         if (!payload.accepted) {
             throw new Error(payload.error ?? "setAgentModel rejected");
         }
+        return payload.notice ?? null;
     }
     async setAgentFeature(agentId, featureId, value) {
         const requestId = this.createRequestId();
@@ -3049,6 +3368,20 @@ export class DaemonClient {
             responseType: "branch_suggestions_response",
         });
     }
+    async searchForge(options, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "forge.search.request",
+                cwd: options.cwd,
+                query: options.query,
+                limit: options.limit,
+                kinds: options.kinds,
+            },
+            responseType: "forge.search.response",
+            timeout: 15000,
+        });
+    }
     async searchGitHub(options, requestId) {
         return this.sendCorrelatedSessionRequest({
             requestId,
@@ -3183,6 +3516,18 @@ export class DaemonClient {
             hash: file.hash ?? null,
         };
     }
+    /**
+     * The fs.file.write RPC: optimistic-concurrency writes keyed by an opaque
+     * revision. The hash-keyed `writeFile` below is kept for callers
+     * that have not moved over.
+     */
+    async writeFsFile(input) {
+        const payload = await this.sendCorrelatedSessionRequest({
+            message: { type: "fs.file.write.request", ...input },
+            responseType: "fs.file.write.response",
+        });
+        return payload.result;
+    }
     /** Conditional save — see FileWriteRequestSchema for the no-clobber contract. */
     async writeFile(options) {
         const payload = await this.sendCorrelatedSessionRequest({
@@ -3201,6 +3546,73 @@ export class DaemonClient {
         });
         return payload.result;
     }
+    /**
+     * Write bytes to a workspace file — the path for generated artifacts the
+     * text write cannot carry (it refuses binary targets outright). Gated on
+     * `features.binaryFileWrite`; there is no client-side substitute, because
+     * the client never touches a workspace file on any platform.
+     *
+     * Shaped like {@link uploadFile}: the JSON request says where the bytes go
+     * and how many to expect, then the bytes follow as file-transfer frames
+     * correlated on the same `requestId`. The daemon answers at FileEnd.
+     */
+    async writeBinaryFile(options) {
+        const bytes = asUint8Array(options.bytes);
+        if (!bytes) {
+            throw new Error("File bytes are required.");
+        }
+        const resolvedRequestId = this.createRequestId(options.requestId);
+        const responsePromise = this.sendCorrelatedSessionRequest({
+            requestId: resolvedRequestId,
+            message: {
+                type: "fs.file.write_binary.request",
+                cwd: options.cwd,
+                path: options.path,
+                size: bytes.byteLength,
+                overwrite: options.overwrite,
+            },
+            responseType: "fs.file.write_binary.response",
+        });
+        this.sendFileTransfer({
+            requestId: resolvedRequestId,
+            bytes,
+            // Nothing downstream reads the mime for a workspace write — the path
+            // decides what the file is — but the frame metadata requires one.
+            mime: "application/octet-stream",
+            chunkSize: options.chunkSize,
+        });
+        const payload = await responsePromise;
+        return payload.result;
+    }
+    /**
+     * FileBegin, chunks, FileEnd. Synchronous through `sendBinaryFrame`, so the
+     * frames leave in order and behind the JSON request that announced them.
+     */
+    sendFileTransfer(input) {
+        this.sendBinaryFrame(encodeFileTransferFrame({
+            opcode: FileTransferOpcode.FileBegin,
+            requestId: input.requestId,
+            metadata: {
+                mime: input.mime,
+                size: input.bytes.byteLength,
+                encoding: "binary",
+                modifiedAt: input.modifiedAt ?? new Date().toISOString(),
+                ...(input.fileName ? { fileName: input.fileName } : {}),
+            },
+        }));
+        const chunkSize = input.chunkSize ?? 1024 * 1024;
+        for (let offset = 0; offset < input.bytes.byteLength; offset += chunkSize) {
+            this.sendBinaryFrame(encodeFileTransferFrame({
+                opcode: FileTransferOpcode.FileChunk,
+                requestId: input.requestId,
+                payload: input.bytes.subarray(offset, Math.min(offset + chunkSize, input.bytes.byteLength)),
+            }));
+        }
+        this.sendBinaryFrame(encodeFileTransferFrame({
+            opcode: FileTransferOpcode.FileEnd,
+            requestId: input.requestId,
+        }));
+    }
     /** Create an empty file or a directory. Never overwrites — see FileCreateResultSchema. */
     async createFileEntry(options) {
         const payload = await this.sendCorrelatedSessionRequest({
@@ -3606,7 +4018,7 @@ export class DaemonClient {
      * torn down when the last disposer runs; events fan out to every caller.
      */
     watchFile(cwd, path, onEvent) {
-        const key = `${cwd}${path}`;
+        const key = `${cwd}${path}`;
         const offMessage = this.on("file.watch.event", (message) => {
             if (message.type !== "file.watch.event") {
                 return;
@@ -3665,29 +4077,14 @@ export class DaemonClient {
             responseType: "file.upload.response",
             options: { skipQueue: true },
         });
-        this.sendBinaryFrame(encodeFileTransferFrame({
-            opcode: FileTransferOpcode.FileBegin,
-            requestId: resolvedRequestId,
-            metadata: {
-                mime: input.mimeType,
-                size: bytes.byteLength,
-                encoding: "binary",
-                modifiedAt,
-                fileName: input.fileName,
-            },
-        }));
-        const chunkSize = input.chunkSize ?? 1024 * 1024;
-        for (let offset = 0; offset < bytes.byteLength; offset += chunkSize) {
-            this.sendBinaryFrame(encodeFileTransferFrame({
-                opcode: FileTransferOpcode.FileChunk,
-                requestId: resolvedRequestId,
-                payload: bytes.subarray(offset, Math.min(offset + chunkSize, bytes.byteLength)),
-            }));
-        }
-        this.sendBinaryFrame(encodeFileTransferFrame({
-            opcode: FileTransferOpcode.FileEnd,
+        this.sendFileTransfer({
             requestId: resolvedRequestId,
-        }));
+            bytes,
+            mime: input.mimeType,
+            fileName: input.fileName,
+            modifiedAt,
+            ...(input.chunkSize === undefined ? {} : { chunkSize: input.chunkSize }),
+        });
         return responsePromise;
     }
     async requestDownloadToken(cwd, path, requestId) {
@@ -5109,6 +5506,10 @@ export class DaemonClient {
                     [CLIENT_CAPS.customModeIcons]: true,
                     [CLIENT_CAPS.reasoningMergeEnum]: true,
                     [CLIENT_CAPS.terminalReflowableSnapshot]: true,
+                    [CLIENT_CAPS.providerSubagents]: true,
+                    // The daemon gates project.updated.notification on this (session.ts),
+                    // so dropping it silently kills cross-session project renames.
+                    [CLIENT_CAPS.projectUpdates]: true,
                     ...this.config.capabilities,
                 },
                 ...(this.config.appVersion ? { appVersion: this.config.appVersion } : {}),
@@ -5198,13 +5599,18 @@ export class DaemonClient {
         }
         const parsed = validateWSOutboundMessage(parsedJson);
         if (!parsed.success) {
-            const msgType = parsedJson != null &&
+            const responseIdentity = extractCorrelatedResponseIdentity(parsedJson);
+            const envelopeType = parsedJson != null &&
                 typeof parsedJson === "object" &&
                 "type" in parsedJson &&
                 typeof parsedJson.type === "string"
                 ? parsedJson.type
                 : "unknown";
+            const msgType = responseIdentity?.responseType ?? envelopeType;
             this.logger.warn({ msgType, error: parsed.error.message }, "Message validation failed");
+            if (responseIdentity) {
+                this.rejectWaitersForRequestId(responseIdentity.requestId, new DaemonProtocolError(responseIdentity));
+            }
             return;
         }
         this.consecutiveLivenessFailures = 0;
@@ -5485,6 +5891,18 @@ export class DaemonClient {
             }
         }
     }
+    rejectWaitersForRequestId(requestId, error) {
+        for (const waiter of Array.from(this.waiters)) {
+            if (waiter.requestId !== requestId) {
+                continue;
+            }
+            this.waiters.delete(waiter);
+            if (waiter.timeoutHandle) {
+                clearTimeout(waiter.timeoutHandle);
+            }
+            waiter.reject(error);
+        }
+    }
     clearWaiters(error) {
         for (const waiter of Array.from(this.waiters)) {
             if (waiter.timeoutHandle) {
@@ -5549,7 +5967,7 @@ export class DaemonClient {
                 return null;
         }
     }
-    waitForWithCancel(predicate, timeout = 30000, _options) {
+    waitForWithCancel(predicate, timeout = 30000, options) {
         // Capture stack trace at call site, not inside setTimeout
         const timeoutError = new Error(`Timeout waiting for message (${timeout}ms)`);
         let waiter = null;
@@ -5582,6 +6000,7 @@ export class DaemonClient {
                 resolve: wrappedResolve,
                 reject: wrappedReject,
                 timeoutHandle,
+                requestId: options?.requestId,
             };
             this.waiters.add(waiter);
         });
@@ -5608,6 +6027,80 @@ export class DaemonClient {
         };
         return { promise, cancel };
     }
+    async cloneGithubProject(input, requestId) {
+        const message = {
+            type: "project.github.clone.request",
+            repo: input.repo,
+            targetDirectory: input.targetDirectory,
+            ...(input.cloneProtocol ? { cloneProtocol: input.cloneProtocol } : {}),
+        };
+        return this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message,
+            timeout: PROJECT_GITHUB_CLONE_TIMEOUT_MS,
+        });
+    }
+    /**
+     * `includeDiscovered` also returns the Scripts the workspace's own project
+     * files declare (package.json scripts today), each tagged with its `source`.
+     * Gate it on `server_info.features.workspaceScriptDiscovery` — an older
+     * daemon ignores the flag and answers with the otto.json list only.
+     */
+    async listWorkspaceScripts(workspaceId, options) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: options?.requestId,
+            message: {
+                type: "workspace.script.list.request",
+                workspaceId,
+                includeDiscovered: options?.includeDiscovered ?? false,
+            },
+            responseType: "workspace.script.list.response",
+        });
+    }
+    async startWorkspaceScriptWithStatus(workspaceId, scriptName, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "workspace.script.start.request", workspaceId, scriptName },
+            responseType: "workspace.script.start.response",
+        });
+    }
+    async stopWorkspaceScript(workspaceId, scriptName, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "workspace.script.stop.request", workspaceId, scriptName },
+            responseType: "workspace.script.stop.response",
+        });
+    }
+    async connectHub(hubUrl, token, requestId) {
+        this.requireHubRelationshipSupport();
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "hub.management.daemon.connect.request", hubUrl, token },
+            responseType: "hub.management.daemon.connect.response",
+        });
+    }
+    async getHubStatus(requestId) {
+        this.requireHubRelationshipSupport();
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "hub.management.daemon.get_status.request" },
+            responseType: "hub.management.daemon.get_status.response",
+        });
+    }
+    async disconnectHub(force = false, requestId) {
+        this.requireHubRelationshipSupport();
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: { type: "hub.management.daemon.disconnect.request", force },
+            responseType: "hub.management.daemon.disconnect.response",
+        });
+    }
+    requireHubRelationshipSupport() {
+        // COMPAT(hubRelationship): added in v0.2.5, drop the gate when floor >= v0.2.5.
+        if (this.lastServerInfoMessage?.features?.hubRelationship !== true) {
+            throw new Error("Update the host to use Hub relationship management.");
+        }
+    }
 }
 function resolveAgentConfig(options) {
     const { config, provider, cwd, env: _env, workspaceId: _workspaceId, initialPrompt: _initialPrompt, images: _images, git: _git, worktreeName: _worktreeName, requestId: _requestId, labels: _labels, ...overrides } = options;

package/dist/index.d.ts

@@ -118,13 +118,13 @@ export interface OttoAgentCreateOptions extends OttoAgentConfigOverrides {
     provider?: CreateAgentRequestMessage["config"]["provider"];
     cwd?: string;
     workspaceId?: string;
+    callerAgentId?: string;
     initialPrompt?: string;
     clientMessageId?: string;
     outputSchema?: Record<string, unknown>;
     images?: CreateAgentRequestMessage["images"];
     attachments?: CreateAgentRequestMessage["attachments"];
     git?: CreateAgentRequestMessage["git"];
-    worktreeName?: string;
     requestId?: string;
     labels?: Record<string, string>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/client",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "description": "Otto client SDK package",
   "license": "AGPL-3.0-or-later",
   "files": [
@@ -36,8 +36,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@otto-code/protocol": "0.7.5",
-    "@otto-code/relay": "0.7.5",
+    "@otto-code/protocol": "0.7.6",
+    "@otto-code/relay": "0.7.6",
     "zod": "^4.4.3"
   },
   "devDependencies": {