@otto-code/protocol 0.7.2 → 0.7.4

package/dist/messages.js

@@ -2143,6 +2143,27 @@ export const AgentDetachResponseMessageSchema = z.object({
     type: z.literal("agent.detach.response"),
     payload: AgentActionResponsePayloadSchema,
 });
+// Move a chat into another workspace, in the same project or a different one.
+//
+// Ownership is one field (see the agent snapshot's `workspaceId`), independent of
+// cwd, so re-stamping it is all a move takes: nothing on disk is keyed by
+// workspace, and clients derive which workspace shows a chat from that field
+// alone.
+//
+// The chat's `cwd` does not change, and does not have to match the target
+// workspace's directory. The daemon has never required those to agree (an
+// agent's cwd can already be a subdirectory of its workspace, and nothing
+// validates one against the other), and a session already rooted on disk cannot
+// honestly be re-rooted. So a moved chat keeps running where it was started.
+//
+// Gated by server_info.features.agentWorkspaceTransfer.
+export const AgentWorkspaceTransferRequestMessageSchema = z.object({
+    type: z.literal("agent.workspace.transfer.request"),
+    agentId: z.string(),
+    // The workspace that should own the chat from now on.
+    workspaceId: z.string(),
+    requestId: z.string(),
+});
 // Stop a running observed subagent (Claude Task / ultracode fan-out). The
 // agentId is the observed subagent's id; the daemon resolves it to the owning
 // provider session's task and calls stopTask. Only observed subagents accept
@@ -2767,6 +2788,20 @@ export const WorkspaceTitleSetResponseSchema = z.object({
     type: z.literal("workspace.title.set.response"),
     payload: WorkspaceTitleSetResponsePayloadSchema,
 });
+export const AgentWorkspaceTransferResponsePayloadSchema = z.object({
+    requestId: z.string(),
+    agentId: z.string(),
+    // Which workspace owns the chat now: the requested one when accepted, the one
+    // it never left when refused. Lets a client correct its optimistic state from
+    // the response alone.
+    workspaceId: z.string().nullable(),
+    accepted: z.boolean(),
+    error: z.string().nullable(),
+});
+export const AgentWorkspaceTransferResponseMessageSchema = z.object({
+    type: z.literal("agent.workspace.transfer.response"),
+    payload: AgentWorkspaceTransferResponsePayloadSchema,
+});
 export const SetVoiceModeResponseMessageSchema = z.object({
     type: z.literal("set_voice_mode_response"),
     payload: z.object({
@@ -3567,6 +3602,11 @@ export const WorkspaceArchivePreflightRequestSchema = z.object({
     requestId: z.string(),
     workspaceId: z.string(),
 });
+// Where the Changes view's base branch came from. Surfaced so the chip can say *why* it is
+// comparing against this branch: an inferred parent is a heuristic over a graph that does not
+// record the answer, and it has to look like one or a wrong guess reads as a bug in the diff.
+// COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4.
+export const CheckoutBaseSourceSchema = z.enum(["user", "inferred", "worktree", "default"]);
 // Repoint a worktree-backed workspace's base branch — what the Changes view diffs
 // against, and what merge-into-base and PR creation target. On a stacked branch the
 // useful base is the parent branch, not the repo default, the same way a forge PR
@@ -3576,8 +3616,14 @@ export const WorktreeBaseRefSetRequestSchema = z.object({
     type: z.literal("worktree.baseRef.set.request"),
     requestId: z.string(),
     workspaceId: z.string(),
-    // Branch name, with or without an `origin/` prefix; null resets to the default branch.
+    // Branch name; null resets to the default branch. An `origin/` prefix is meaningful and is
+    // kept — `main` and `origin/main` are different comparisons whenever the two have drifted.
     baseRef: z.string().nullable(),
+    // Forget the remembered base and detect the branch's parent again, ignoring `baseRef`.
+    // The escape hatch for a wrong guess: parent detection is a heuristic over a graph that does
+    // not record the answer, and the result is sticky, so it has to be re-runnable on demand.
+    // COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4.
+    redetect: z.boolean().optional(),
 });
 // Create a new workspace record. Unlike open_project, this never deduplicates by
 // directory: it always produces a fresh workspace. The source discriminates
@@ -3602,7 +3648,10 @@ export const WorkspaceCreateRequestSchema = z.object({
             cwd: z.string().optional(),
             projectId: z.string().optional(),
             action: z.enum(["branch-off", "checkout"]).optional(),
-            // Target branch name for checkout, or new branch name for branch-off.
+            // Branch to check out for "checkout". For "branch-off" this is the BASE to
+            // cut from, not the branch being created -- the new branch name comes from
+            // worktreeSlug (see resolveWorktreeCreationIntent). Omit it to branch off
+            // the repository default.
             refName: z.string().min(1).optional(),
             baseBranch: z.string().optional(),
             githubPrNumber: z.number().int().positive().optional(),
@@ -3979,12 +4028,18 @@ export const CodeRenameUndoRequestSchema = z.object({
  * config RPCs because none of it is configuration: which servers this machine can
  * actually supply, and which are running right now.
  *
- * `cwd` scopes the availability check — a server can be present in one workspace's
- * `node_modules` and absent in another's.
+ * Omit `cwd` for the host-wide answer, which is what the settings screen asks for: every
+ * row this daemon knows, resolved against the rungs a host has (bundled, PATH). Passing a
+ * `cwd` additionally probes that workspace's `node_modules/.bin`, since a server can be
+ * present in one project and absent from another. Optional rather than removed because
+ * older clients still send it.
+ *
+ * COMPAT(lspHostServers): `cwd` became optional in v0.7.3; gate lives in
+ * features.lspHostServers.
  */
 export const LspServersListRequestSchema = z.object({
     type: z.literal("lsp.servers.list.request"),
-    cwd: z.string(),
+    cwd: z.string().optional(),
     requestId: z.string(),
 });
 /** Stop one running server, so a user who suspects it of hogging memory can kill it. */
@@ -4292,6 +4347,7 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     SetAgentThinkingRequestMessageSchema,
     SetAgentFeatureRequestMessageSchema,
     AgentDetachRequestMessageSchema,
+    AgentWorkspaceTransferRequestMessageSchema,
     AgentSubagentStopRequestMessageSchema,
     AgentBackgroundTaskStopRequestMessageSchema,
     AgentBackgroundTaskClearRequestMessageSchema,
@@ -4692,6 +4748,13 @@ export const ServerInfoStatusPayloadSchema = z
         // the outline/fuzzy-finder source and the no-server fallback.
         // COMPAT(lsp): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
         lsp: z.boolean().optional(),
+        // The daemon answers `lsp.servers.list` host-wide, with no `cwd`. The settings
+        // screen is a host screen: it lists every language server this machine knows how
+        // to run and whether it can supply the binary, and it must not need a workspace
+        // open to say so. An older daemon rejects a request with no `cwd`, so without the
+        // flag the client says to update the host rather than showing an empty screen.
+        // COMPAT(lspHostServers): added in v0.7.3, drop the gate when daemon floor >= v0.7.3.
+        lspHostServers: z.boolean().optional(),
         // The Solution view — the daemon can discover solutions and serve
         // `code.solution.*`. Deliberately NOT implied by `lsp`: there is no
         // project-structure request in LSP, so this subsystem is independent of
@@ -4747,6 +4810,13 @@ export const ServerInfoStatusPayloadSchema = z
         // the daemon can write the worktree's metadata.
         // COMPAT(worktreeDiffBase): added in v0.6.8, drop the gate when daemon floor >= v0.6.8.
         worktreeDiffBase: z.boolean().optional(),
+        // Set when the daemon stores the diff base *per branch*, which is what lets any git
+        // checkout repoint it rather than only an Otto worktree — a plain checkout's gitdir is
+        // shared by every branch in it, so a single stored base would bleed across branch
+        // switches. Also gates parent-branch detection, the `origin/`-qualified pin, and the
+        // re-detect action. Without it the client keeps the worktree-only picker.
+        // COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4, drop the gate when daemon floor >= v0.7.4.
+        checkoutDiffBaseAnyRepo: z.boolean().optional(),
         // Set when the daemon persists the host-level hideMergeIntoBaseAction
         // workspace policy (read/written via the daemon config RPCs). Without
         // it the client hides the Workspaces toggle, since patching the field
@@ -4852,6 +4922,12 @@ export const ServerInfoStatusPayloadSchema = z
         // the daemon half of the Storage section; the app-side preview cache row
         // is local and always shown.
         attachmentStorage: z.boolean().optional(),
+        // COMPAT(agentWorkspaceTransfer): added in v0.7.4, drop the gate when
+        // daemon floor >= v0.7.4. Set when the daemon serves
+        // `agent.workspace.transfer` — moving a chat to another workspace over
+        // the same directory. The client cannot restamp ownership itself (it is
+        // daemon state), so an old daemon simply does not get the menu item.
+        agentWorkspaceTransfer: z.boolean().optional(),
     })
         .optional(),
 })
@@ -5556,6 +5632,9 @@ export const WorktreeBaseRefSetResponseSchema = z.object({
         baseRef: z.string().nullable(),
         // The stored base is the repository default branch (no stacked-branch override).
         isDefault: z.boolean(),
+        // Where the resulting base came from, so the client can label it without a refetch.
+        // COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4.
+        baseSource: CheckoutBaseSourceSchema.optional(),
         error: z.string().nullable(),
     }),
 });
@@ -6032,6 +6111,15 @@ const CheckoutStatusCommonSchema = z.object({
     // COMPAT(checkoutStatusGitStateAt): added in v0.6.8; absent from older daemons.
     // Drop the optional marker when floor >= v0.6.8 (target 2027-01-24).
     gitStateAt: z.number().optional(),
+    // Where `baseRef` came from, so the base chip can label an inferred parent as a guess rather
+    // than presenting it with the same authority as an explicit pick.
+    // COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4.
+    baseSource: CheckoutBaseSourceSchema.optional(),
+    // Whether this checkout can have its base repointed. True for any git checkout on a daemon
+    // that stores the base per branch; older daemons only supported Otto worktrees, which the
+    // client inferred from isOttoOwnedWorktree.
+    // COMPAT(checkoutDiffBaseAnyRepo): added in v0.7.4.
+    isBaseEditable: z.boolean().optional(),
 });
 const CheckoutStatusNotGitSchema = CheckoutStatusCommonSchema.extend({
     isGit: z.literal(false),
@@ -7316,6 +7404,14 @@ export const LspLanguageStateSchema = z.object({
     /** Which discovery rung supplied it (`workspaceBin` / `bundled` / `path`), or null. */
     rung: z.string().nullable(),
     bin: z.string(),
+    /**
+     * Every rung this row can ever be supplied from, in resolution order. A row whose only
+     * rung is `workspaceBin` is supplied by the project it runs in and by nothing else, so
+     * `installed: false` from a host-wide check means "the project brings it", not "missing".
+     */
+    discovery: z.array(z.string()).optional(),
+    /** Absolute path to the resolved executable, so the toolchain behind a row is nameable. */
+    path: z.string().nullable().optional(),
     extensions: z.array(z.string()),
     /** Plain-words index cost, so the toggle states its own price. */
     indexCost: z.string(),
@@ -7946,6 +8042,7 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SetAgentThinkingResponseMessageSchema,
     SetAgentFeatureResponseMessageSchema,
     AgentDetachResponseMessageSchema,
+    AgentWorkspaceTransferResponseMessageSchema,
     AgentQueueRemoveResponseMessageSchema,
     AgentQueueReorderResponseMessageSchema,
     AgentQueueClearResponseMessageSchema,

package/dist/validation/ws-outbound-schema-metadata.d.ts

@@ -2599,6 +2599,12 @@ export declare const WSOutboundMessageSchema: {
                 workspaceId: import("zod").ZodString;
                 baseRef: import("zod").ZodNullable<import("zod").ZodString>;
                 isDefault: import("zod").ZodBoolean;
+                baseSource: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    default: "default";
+                    worktree: "worktree";
+                    user: "user";
+                    inferred: "inferred";
+                }>>;
                 error: import("zod").ZodNullable<import("zod").ZodString>;
             }, import("zod/v4/core").$strip>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
@@ -4643,6 +4649,15 @@ export declare const WSOutboundMessageSchema: {
                 error: import("zod").ZodNullable<import("zod").ZodString>;
                 notice: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodType<import("../agent-types.js").AgentProviderNotice, unknown, import("zod/v4/core").$ZodTypeInternals<import("../agent-types.js").AgentProviderNotice, unknown>>>>;
             }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"agent.workspace.transfer.response">;
+            payload: import("zod").ZodObject<{
+                requestId: import("zod").ZodString;
+                agentId: import("zod").ZodString;
+                workspaceId: import("zod").ZodNullable<import("zod").ZodString>;
+                accepted: import("zod").ZodBoolean;
+                error: import("zod").ZodNullable<import("zod").ZodString>;
+            }, import("zod/v4/core").$strip>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"agent.queue.remove.response">;
             payload: import("zod").ZodObject<{
@@ -5199,6 +5214,13 @@ export declare const WSOutboundMessageSchema: {
                 }, import("zod/v4/core").$strip>>;
                 requestId: import("zod").ZodString;
                 gitStateAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+                baseSource: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    default: "default";
+                    worktree: "worktree";
+                    user: "user";
+                    inferred: "inferred";
+                }>>;
+                isBaseEditable: import("zod").ZodOptional<import("zod").ZodBoolean>;
                 isGit: import("zod").ZodLiteral<false>;
                 isOttoOwnedWorktree: import("zod").ZodLiteral<false>;
                 repoRoot: import("zod").ZodNull;
@@ -5223,6 +5245,13 @@ export declare const WSOutboundMessageSchema: {
                 }, import("zod/v4/core").$strip>>;
                 requestId: import("zod").ZodString;
                 gitStateAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+                baseSource: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    default: "default";
+                    worktree: "worktree";
+                    user: "user";
+                    inferred: "inferred";
+                }>>;
+                isBaseEditable: import("zod").ZodOptional<import("zod").ZodBoolean>;
                 isGit: import("zod").ZodLiteral<true>;
                 isOttoOwnedWorktree: import("zod").ZodLiteral<false>;
                 repoRoot: import("zod").ZodString;
@@ -5251,6 +5280,13 @@ export declare const WSOutboundMessageSchema: {
                 }, import("zod/v4/core").$strip>>;
                 requestId: import("zod").ZodString;
                 gitStateAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+                baseSource: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    default: "default";
+                    worktree: "worktree";
+                    user: "user";
+                    inferred: "inferred";
+                }>>;
+                isBaseEditable: import("zod").ZodOptional<import("zod").ZodBoolean>;
                 isGit: import("zod").ZodLiteral<true>;
                 isOttoOwnedWorktree: import("zod").ZodLiteral<true>;
                 repoRoot: import("zod").ZodString;
@@ -5282,6 +5318,13 @@ export declare const WSOutboundMessageSchema: {
                 }, import("zod/v4/core").$strip>>;
                 requestId: import("zod").ZodString;
                 gitStateAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+                baseSource: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    default: "default";
+                    worktree: "worktree";
+                    user: "user";
+                    inferred: "inferred";
+                }>>;
+                isBaseEditable: import("zod").ZodOptional<import("zod").ZodBoolean>;
                 isGit: import("zod").ZodLiteral<false>;
                 isOttoOwnedWorktree: import("zod").ZodLiteral<false>;
                 repoRoot: import("zod").ZodNull;
@@ -5306,6 +5349,13 @@ export declare const WSOutboundMessageSchema: {
                 }, import("zod/v4/core").$strip>>;
                 requestId: import("zod").ZodString;
                 gitStateAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+                baseSource: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    default: "default";
+                    worktree: "worktree";
+                    user: "user";
+                    inferred: "inferred";
+                }>>;
+                isBaseEditable: import("zod").ZodOptional<import("zod").ZodBoolean>;
                 isGit: import("zod").ZodLiteral<true>;
                 isOttoOwnedWorktree: import("zod").ZodLiteral<false>;
                 repoRoot: import("zod").ZodString;
@@ -5334,6 +5384,13 @@ export declare const WSOutboundMessageSchema: {
                 }, import("zod/v4/core").$strip>>;
                 requestId: import("zod").ZodString;
                 gitStateAt: import("zod").ZodOptional<import("zod").ZodNumber>;
+                baseSource: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    default: "default";
+                    worktree: "worktree";
+                    user: "user";
+                    inferred: "inferred";
+                }>>;
+                isBaseEditable: import("zod").ZodOptional<import("zod").ZodBoolean>;
                 isGit: import("zod").ZodLiteral<true>;
                 isOttoOwnedWorktree: import("zod").ZodLiteral<true>;
                 repoRoot: import("zod").ZodString;
@@ -7855,6 +7912,8 @@ export declare const WSOutboundMessageSchema: {
                     running: import("zod").ZodBoolean;
                     rung: import("zod").ZodNullable<import("zod").ZodString>;
                     bin: import("zod").ZodString;
+                    discovery: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    path: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
                     extensions: import("zod").ZodArray<import("zod").ZodString>;
                     indexCost: import("zod").ZodString;
                 }, import("zod/v4/core").$strip>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/protocol",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Otto shared protocol schemas and wire types",
   "license": "AGPL-3.0-or-later",
   "files": [