@otto-code/protocol 0.5.0 → 0.5.1

package/dist/messages.js

@@ -133,13 +133,17 @@ export const MutableGitHostingConfigSchema = z
     .passthrough();
 // Canonical personality roles, in display order. Kept as an exported const so
 // the daemon and app share one vocabulary, but the wire schema stores roles as
-// plain strings (below) — adding an 8th role later must never break an older
-// peer's parsing. Consumers filter incoming role arrays to this known set.
+// plain strings (below) — adding a role later must never break an older peer's
+// parsing. Consumers filter incoming role arrays to this known set. The retired
+// "worker" role is mapped to "coder" on the way in (see LEGACY_ROLE_ALIASES in
+// agent-personalities.ts) so personalities persisted before the split keep their
+// role rather than silently losing it.
 export const PERSONALITY_ROLES = [
     "chatter",
     "artificer",
     "scheduler",
-    "worker",
+    "writer",
+    "coder",
     "judger",
     "advisor",
     "orchestrator",
@@ -1483,6 +1487,78 @@ export const CheckoutCommitRequestSchema = z.object({
     addAll: z.boolean().optional(),
     requestId: z.string(),
 });
+// One entry in a git operation log (the "Git Commit"/"Git Push" log panes).
+// `seq` is a per-(cwd, operation) monotonic counter used for client-side
+// dedup between backfill and live pushes.
+export const GitOperationLogEntrySchema = z.object({
+    seq: z.number(),
+    timestamp: z.string(),
+    level: z.enum(["info", "output", "error"]),
+    text: z.string(),
+});
+// Backfill for a git operation log pane. `operation` is an open string on the
+// wire ("commit" | "pull" | "push" today) so newly watchable operations don't
+// break old peers. Gated by server_info.features.checkoutGitLog.
+export const CheckoutGitGetOperationLogRequestSchema = z.object({
+    type: z.literal("checkout.git.get_operation_log.request"),
+    cwd: z.string(),
+    operation: z.string(),
+    requestId: z.string(),
+});
+export const CheckoutGitGetOperationLogResponseSchema = z.object({
+    type: z.literal("checkout.git.get_operation_log.response"),
+    payload: z.object({
+        cwd: z.string(),
+        operation: z.string(),
+        entries: z.array(GitOperationLogEntrySchema),
+        requestId: z.string(),
+    }),
+});
+// Live append notification, broadcast to connected clients while a watched git
+// operation runs. Carries only the appended entries; `seq` orders them against
+// the backfill.
+export const CheckoutGitLogAppendedNotificationSchema = z.object({
+    type: z.literal("checkout.git.log_appended.notification"),
+    payload: z.object({
+        cwd: z.string(),
+        operation: z.string(),
+        entries: z.array(GitOperationLogEntrySchema),
+    }),
+});
+// Namespaced successor to checkout_commit_request: per-file selection and
+// structured errors. Gated by server_info.features.checkoutGitCommit; the flat
+// RPC stays accepted for old clients.
+export const CheckoutGitCommitRequestSchema = z.object({
+    type: z.literal("checkout.git.commit.request"),
+    cwd: z.string(),
+    message: z.string(),
+    // Repo-relative paths to stage and commit. Only these paths land in the
+    // commit, even if other changes are already staged.
+    paths: z.array(z.string()),
+    // Set after the user confirms committing while agents are running in this
+    // workspace; without it the daemon refuses with kind "agents_running".
+    allowWithRunningAgents: z.boolean().optional(),
+    requestId: z.string(),
+});
+// Resolve which agent the daemon would use to author a commit message for this
+// checkout (the "writer" role) so the client can name it in a confirmation
+// before running the AI-authored commit. A pure query — it never commits. Gated
+// by server_info.features.checkoutGitCommitAgent.
+export const CheckoutGitCommitAgentRequestSchema = z.object({
+    type: z.literal("checkout.git.commit_agent.request"),
+    cwd: z.string(),
+    requestId: z.string(),
+});
+// Discard uncommitted working-tree changes for specific repo-relative paths
+// (restore tracked files from HEAD, delete newly-added files). Gated by
+// server_info.features.checkoutGitRollback.
+export const CheckoutGitRollbackRequestSchema = z.object({
+    type: z.literal("checkout.git.rollback.request"),
+    cwd: z.string(),
+    // Repo-relative paths whose uncommitted changes should be discarded.
+    paths: z.array(z.string()),
+    requestId: z.string(),
+});
 export const CheckoutMergeRequestSchema = z.object({
     type: z.literal("checkout_merge_request"),
     cwd: z.string(),
@@ -2170,6 +2246,10 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     SubscribeCheckoutDiffRequestSchema,
     UnsubscribeCheckoutDiffRequestSchema,
     CheckoutCommitRequestSchema,
+    CheckoutGitCommitRequestSchema,
+    CheckoutGitCommitAgentRequestSchema,
+    CheckoutGitRollbackRequestSchema,
+    CheckoutGitGetOperationLogRequestSchema,
     CheckoutMergeRequestSchema,
     CheckoutMergeFromBaseRequestSchema,
     CheckoutPullRequestSchema,
@@ -2464,6 +2544,14 @@ export const ServerInfoStatusPayloadSchema = z
         ttsPreview: z.boolean().optional(),
         // COMPAT(setAgentPersonality): added in v0.5.0, drop the gate when daemon floor >= v0.5.0.
         setAgentPersonality: z.boolean().optional(),
+        // COMPAT(checkoutGitCommit): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
+        checkoutGitCommit: z.boolean().optional(),
+        // COMPAT(checkoutGitCommitAgent): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
+        checkoutGitCommitAgent: z.boolean().optional(),
+        // COMPAT(checkoutGitRollback): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
+        checkoutGitRollback: z.boolean().optional(),
+        // COMPAT(checkoutGitLog): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
+        checkoutGitLog: z.boolean().optional(),
     })
         .optional(),
 })
@@ -3495,6 +3583,101 @@ export const CheckoutCommitResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+const CheckoutGitCommitRunningAgentSchema = z.object({
+    id: z.string(),
+    title: z.string().nullable(),
+});
+export const CheckoutGitCommitErrorSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("agents_running"),
+        agents: z.array(CheckoutGitCommitRunningAgentSchema),
+    }),
+    z.object({
+        kind: z.literal("identity_missing"),
+        missingName: z.boolean(),
+        missingEmail: z.boolean(),
+    }),
+    z.object({
+        kind: z.literal("hook_failed"),
+        output: z.string(),
+        exitCode: z.number().nullable(),
+    }),
+    z.object({
+        kind: z.literal("signing_failed"),
+        detail: z.string(),
+    }),
+    z.object({
+        kind: z.literal("nothing_to_commit"),
+    }),
+    z.object({
+        kind: z.literal("git_failed"),
+        detail: z.string(),
+    }),
+]);
+export const CheckoutGitCommitResponseSchema = z.object({
+    type: z.literal("checkout.git.commit.response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        commitSha: z.string().nullable(),
+        error: CheckoutGitCommitErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+// The agent the daemon resolved to author a commit message. "personality" when
+// an available role-matched Agent Personality wins the mini-task routing (its
+// name plus the bound provider/model); "provider" when a bare provider/model is
+// used instead; "none" when nothing is configured to run the task, in which case
+// the client refuses the AI commit rather than falling back to placeholder text.
+export const CommitMessageAgentSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("personality"),
+        personalityId: z.string(),
+        personalityName: z.string(),
+        provider: z.string(),
+        providerLabel: z.string(),
+        model: z.string().nullable(),
+        modelLabel: z.string().nullable(),
+    }),
+    z.object({
+        kind: z.literal("provider"),
+        provider: z.string(),
+        providerLabel: z.string(),
+        model: z.string().nullable(),
+        modelLabel: z.string().nullable(),
+    }),
+    z.object({
+        kind: z.literal("none"),
+    }),
+]);
+export const CheckoutGitCommitAgentResponseSchema = z.object({
+    type: z.literal("checkout.git.commit_agent.response"),
+    payload: z.object({
+        cwd: z.string(),
+        agent: CommitMessageAgentSchema,
+        requestId: z.string(),
+    }),
+});
+export const CheckoutGitRollbackErrorSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("nothing_to_rollback"),
+    }),
+    z.object({
+        kind: z.literal("git_failed"),
+        detail: z.string(),
+    }),
+]);
+export const CheckoutGitRollbackResponseSchema = z.object({
+    type: z.literal("checkout.git.rollback.response"),
+    payload: z.object({
+        cwd: z.string(),
+        success: z.boolean(),
+        // Repo-relative paths whose changes were discarded.
+        rolledBackPaths: z.array(z.string()),
+        error: CheckoutGitRollbackErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
 export const CheckoutMergeResponseSchema = z.object({
     type: z.literal("checkout_merge_response"),
     payload: z.object({
@@ -4535,6 +4718,11 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     SubscribeCheckoutDiffResponseSchema,
     CheckoutDiffUpdateSchema,
     CheckoutCommitResponseSchema,
+    CheckoutGitCommitResponseSchema,
+    CheckoutGitCommitAgentResponseSchema,
+    CheckoutGitRollbackResponseSchema,
+    CheckoutGitGetOperationLogResponseSchema,
+    CheckoutGitLogAppendedNotificationSchema,
     CheckoutMergeResponseSchema,
     CheckoutMergeFromBaseResponseSchema,
     CheckoutPullResponseSchema,

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

@@ -4297,6 +4297,107 @@ export declare const WSOutboundMessageSchema: {
                 }, import("zod/v4/core").$strip>>;
                 requestId: import("zod").ZodString;
             }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"checkout.git.commit.response">;
+            payload: import("zod").ZodObject<{
+                cwd: import("zod").ZodString;
+                success: import("zod").ZodBoolean;
+                commitSha: import("zod").ZodNullable<import("zod").ZodString>;
+                error: import("zod").ZodNullable<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"agents_running">;
+                    agents: import("zod").ZodArray<import("zod").ZodObject<{
+                        id: import("zod").ZodString;
+                        title: import("zod").ZodNullable<import("zod").ZodString>;
+                    }, import("zod/v4/core").$strip>>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"identity_missing">;
+                    missingName: import("zod").ZodBoolean;
+                    missingEmail: import("zod").ZodBoolean;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"hook_failed">;
+                    output: import("zod").ZodString;
+                    exitCode: import("zod").ZodNullable<import("zod").ZodNumber>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"signing_failed">;
+                    detail: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"nothing_to_commit">;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"git_failed">;
+                    detail: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>], "kind">>;
+                requestId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"checkout.git.commit_agent.response">;
+            payload: import("zod").ZodObject<{
+                cwd: import("zod").ZodString;
+                agent: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"personality">;
+                    personalityId: import("zod").ZodString;
+                    personalityName: import("zod").ZodString;
+                    provider: import("zod").ZodString;
+                    providerLabel: import("zod").ZodString;
+                    model: import("zod").ZodNullable<import("zod").ZodString>;
+                    modelLabel: import("zod").ZodNullable<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"provider">;
+                    provider: import("zod").ZodString;
+                    providerLabel: import("zod").ZodString;
+                    model: import("zod").ZodNullable<import("zod").ZodString>;
+                    modelLabel: import("zod").ZodNullable<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"none">;
+                }, import("zod/v4/core").$strip>], "kind">;
+                requestId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"checkout.git.rollback.response">;
+            payload: import("zod").ZodObject<{
+                cwd: import("zod").ZodString;
+                success: import("zod").ZodBoolean;
+                rolledBackPaths: import("zod").ZodArray<import("zod").ZodString>;
+                error: import("zod").ZodNullable<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"nothing_to_rollback">;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"git_failed">;
+                    detail: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>], "kind">>;
+                requestId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"checkout.git.get_operation_log.response">;
+            payload: import("zod").ZodObject<{
+                cwd: import("zod").ZodString;
+                operation: import("zod").ZodString;
+                entries: import("zod").ZodArray<import("zod").ZodObject<{
+                    seq: import("zod").ZodNumber;
+                    timestamp: import("zod").ZodString;
+                    level: import("zod").ZodEnum<{
+                        error: "error";
+                        output: "output";
+                        info: "info";
+                    }>;
+                    text: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>>;
+                requestId: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"checkout.git.log_appended.notification">;
+            payload: import("zod").ZodObject<{
+                cwd: import("zod").ZodString;
+                operation: import("zod").ZodString;
+                entries: import("zod").ZodArray<import("zod").ZodObject<{
+                    seq: import("zod").ZodNumber;
+                    timestamp: import("zod").ZodString;
+                    level: import("zod").ZodEnum<{
+                        error: "error";
+                        output: "output";
+                        info: "info";
+                    }>;
+                    text: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>;
         }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
             type: import("zod").ZodLiteral<"checkout_merge_response">;
             payload: import("zod").ZodObject<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/protocol",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Otto shared protocol schemas and wire types",
   "files": [
     "dist",