@otto-code/protocol 0.6.5 → 0.6.6

package/dist/messages.js

@@ -199,20 +199,25 @@ const AgentPersonalityVoiceSchema = z
     name: z.string().min(1),
 })
     .passthrough();
-// The three Visualizer lifecycle moments a personality voice-cue line can
-// belong to. Protocol owns this vocabulary — the daemon's cue generator, the
-// personality editor, and the Visualizer playback hook all import it from here.
-export const CUE_MOMENTS = ["join", "thinking", "done"];
+// The Visualizer lifecycle moments a personality voice-cue line can belong to.
+// Protocol owns this vocabulary — the daemon's cue generator, the personality
+// editor, and the Visualizer playback hook all import it from here.
+// "waiting" is the parent's turn ending while its observed sub-agents are still
+// running; it DEFERS "done" rather than replacing it (see docs/visualizer.md).
+export const CUE_MOMENTS = ["join", "thinking", "waiting", "done"];
 // Pre-generated (and user-editable) spoken "voice cue" lines for the personality
-// — a few short variations for each of three Visualizer moments (its node joins
-// the graph, first starts thinking, completes). Stored on the personality so
-// they're deterministic and hand-tunable in the editor; the Visualizer reads
-// them directly (no runtime generation). All groups optional/loose — a
-// personality may have none, or only some. See docs/visualizer.md "Voice cues".
+// — a few short variations for each Visualizer moment (its node joins the graph,
+// first starts thinking, finishes its turn but waits on sub-agents, completes).
+// Stored on the personality so they're deterministic and hand-tunable in the
+// editor; the Visualizer reads them directly (no runtime generation). All groups
+// optional/loose — a personality may have none, or only some (personalities
+// authored before "waiting" existed simply stay silent for that moment).
+// See docs/visualizer.md "Voice cues".
 const AgentPersonalityVoiceCuesSchema = z
     .object({
     join: z.array(z.string()).optional(),
     thinking: z.array(z.string()).optional(),
+    waiting: z.array(z.string()).optional(),
     done: z.array(z.string()).optional(),
 })
     .passthrough();
@@ -2401,6 +2406,57 @@ export const CheckoutGitRollbackRequestSchema = z.object({
     allowWithRunningAgents: z.boolean().optional(),
     requestId: z.string(),
 });
+// ── Git file investigation (local git, no hosting provider) ─────────────────
+// History / per-commit diff / blame / origin commit for one file or one line
+// range within it. Everything below is plain local git: it works in a repo with
+// no remote and no forge connection, and it is provider-neutral by construction
+// (it inspects the repo, not an agent), so there is no per-provider rollout to
+// look for. Gated by server_info.features.checkoutGitFileHistory.
+// Commits that touched a file, newest first. Whole-file mode follows renames;
+// passing startLine/endLine switches to `git log -L` for that range instead.
+export const CheckoutGitFileHistoryRequestSchema = z.object({
+    type: z.literal("checkout.git.get_file_history.request"),
+    cwd: z.string(),
+    // Repo-relative path, as the file is named today.
+    path: z.string(),
+    limit: z.number().int().positive().optional(),
+    offset: z.number().int().nonnegative().optional(),
+    // 1-based inclusive line range. Both or neither.
+    startLine: z.number().int().positive().optional(),
+    endLine: z.number().int().positive().optional(),
+    requestId: z.string(),
+});
+// What a single commit did to a single file, as a unified diff. `path` must be
+// the file's name *at that commit* (history entries carry it) or the pathspec
+// misses across a rename.
+export const CheckoutGitFileCommitDiffRequestSchema = z.object({
+    type: z.literal("checkout.git.get_file_commit_diff.request"),
+    cwd: z.string(),
+    path: z.string(),
+    sha: z.string(),
+    ignoreWhitespace: z.boolean().optional(),
+    requestId: z.string(),
+});
+// One page of blame. Always paged — blaming a large file whole would block the
+// daemon — so the client walks the file a page at a time.
+export const CheckoutGitFileBlameRequestSchema = z.object({
+    type: z.literal("checkout.git.get_file_blame.request"),
+    cwd: z.string(),
+    path: z.string(),
+    startLine: z.number().int().positive().optional(),
+    lineCount: z.number().int().positive().optional(),
+    // Blame at a specific commit instead of the working tree.
+    sha: z.string().optional(),
+    requestId: z.string(),
+});
+// The commit that first added the file ("who originally wrote this"), following
+// renames so a moved file reports its true origin.
+export const CheckoutGitFileOriginRequestSchema = z.object({
+    type: z.literal("checkout.git.get_file_origin.request"),
+    cwd: z.string(),
+    path: z.string(),
+    requestId: z.string(),
+});
 export const CheckoutMergeRequestSchema = z.object({
     type: z.literal("checkout_merge_request"),
     cwd: z.string(),
@@ -3105,6 +3161,10 @@ export const SessionInboundMessageSchema = z.discriminatedUnion("type", [
     CheckoutGitCommitAgentRequestSchema,
     CheckoutGitRollbackRequestSchema,
     CheckoutGitGetOperationLogRequestSchema,
+    CheckoutGitFileHistoryRequestSchema,
+    CheckoutGitFileCommitDiffRequestSchema,
+    CheckoutGitFileBlameRequestSchema,
+    CheckoutGitFileOriginRequestSchema,
     RunsGetSnapshotRequestSchema,
     RunsGateRespondRequestSchema,
     RunsCancelRequestSchema,
@@ -3428,6 +3488,12 @@ export const ServerInfoStatusPayloadSchema = z
         checkoutGitRollback: z.boolean().optional(),
         // COMPAT(checkoutGitLog): added in v0.5.1, drop the gate when daemon floor >= v0.5.1.
         checkoutGitLog: z.boolean().optional(),
+        // Local-git file investigation: history, per-commit diff, blame, origin
+        // commit — for a whole file or a line range. No forge connection needed
+        // and no per-provider rollout; it is git, so every provider gets it at
+        // once.
+        // COMPAT(checkoutGitFileHistory): added in v0.6.6, drop the gate when daemon floor >= v0.6.6.
+        checkoutGitFileHistory: z.boolean().optional(),
         // COMPAT(agentTeams): added in v0.5.2, drop the gate when daemon floor >= v0.5.2.
         agentTeams: z.boolean().optional(),
         // COMPAT(modelTierOverrides): added in v0.5.2, drop the gate when daemon floor >= v0.5.2.
@@ -4645,6 +4711,116 @@ export const CheckoutGitRollbackResponseSchema = z.object({
         requestId: z.string(),
     }),
 });
+// ── Git file investigation responses ────────────────────────────────────────
+// A structured failure any of the four file-investigation RPCs can report. They
+// are pure reads, so the failure modes are narrow: not a repo, path/revision
+// rejected, or git itself refused.
+export const CheckoutGitFileErrorSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("not_git_repo"),
+    }),
+    z.object({
+        kind: z.literal("invalid_path"),
+        detail: z.string(),
+    }),
+    z.object({
+        kind: z.literal("git_failed"),
+        detail: z.string(),
+    }),
+]);
+export const GitFileHistoryEntrySchema = z.object({
+    sha: z.string(),
+    shortSha: z.string(),
+    subject: z.string(),
+    body: z.string(),
+    authorName: z.string(),
+    authorEmail: z.string(),
+    // Unix seconds.
+    authoredAt: z.number(),
+    committerName: z.string(),
+    committedAt: z.number(),
+    // The file's name at this commit — differs from the requested path across a
+    // rename. Diff requests must echo this one back, not the current name.
+    path: z.string(),
+    previousPath: z.string().optional(),
+    // Single-letter git status (A/M/D/R/C).
+    changeKind: z.string().optional(),
+    isMerge: z.boolean(),
+    // Parent object names, so a diff view can name the revision it is comparing
+    // against instead of writing "<sha>^". Empty for a root commit.
+    parentShas: z.array(z.string()).optional(),
+});
+export const CheckoutGitFileHistoryResponseSchema = z.object({
+    type: z.literal("checkout.git.get_file_history.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        entries: z.array(GitFileHistoryEntrySchema),
+        hasMore: z.boolean(),
+        error: CheckoutGitFileErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutGitFileCommitDiffResponseSchema = z.object({
+    type: z.literal("checkout.git.get_file_commit_diff.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        sha: z.string(),
+        diff: z.string(),
+        // Highlighted/parsed form of the same diff, when it parsed cleanly.
+        structured: z.array(ParsedDiffFileSchema).optional(),
+        // The file's previous revision — the diff's left-hand side, and the honest
+        // label for it. Absent when this revision created the file.
+        previousSha: z.string().optional(),
+        previousPath: z.string().optional(),
+        truncated: z.boolean(),
+        error: CheckoutGitFileErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const GitBlameLineSchema = z.object({
+    line: z.number(),
+    sha: z.string(),
+    originalLine: z.number(),
+});
+// Blame commit metadata is deduped by sha rather than inlined per line: a
+// thousand-line page usually references a handful of commits.
+export const GitBlameCommitSchema = z.object({
+    sha: z.string(),
+    shortSha: z.string(),
+    summary: z.string(),
+    authorName: z.string(),
+    authorEmail: z.string(),
+    authoredAt: z.number(),
+    path: z.string().optional(),
+});
+export const CheckoutGitFileBlameResponseSchema = z.object({
+    type: z.literal("checkout.git.get_file_blame.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        lines: z.array(GitBlameLineSchema),
+        commits: z.array(GitBlameCommitSchema),
+        startLine: z.number(),
+        endLine: z.number(),
+        reachedEndOfFile: z.boolean(),
+        error: CheckoutGitFileErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
+export const CheckoutGitFileOriginResponseSchema = z.object({
+    type: z.literal("checkout.git.get_file_origin.response"),
+    payload: z.object({
+        cwd: z.string(),
+        path: z.string(),
+        // Null when the file has no commit history (never committed, or a shallow
+        // clone that does not reach its creation).
+        entry: GitFileHistoryEntrySchema.nullable(),
+        error: CheckoutGitFileErrorSchema.nullable(),
+        requestId: z.string(),
+    }),
+});
 export const CheckoutMergeResponseSchema = z.object({
     type: z.literal("checkout_merge_response"),
     payload: z.object({
@@ -5707,6 +5883,10 @@ export const SessionOutboundMessageSchema = z.discriminatedUnion("type", [
     CheckoutGitRollbackResponseSchema,
     CheckoutGitGetOperationLogResponseSchema,
     CheckoutGitLogAppendedNotificationSchema,
+    CheckoutGitFileHistoryResponseSchema,
+    CheckoutGitFileCommitDiffResponseSchema,
+    CheckoutGitFileBlameResponseSchema,
+    CheckoutGitFileOriginResponseSchema,
     RunsGetSnapshotResponseSchema,
     RunsUpdatedNotificationSchema,
     RunsGateRespondResponseSchema,

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

@@ -3511,6 +3511,7 @@ export declare const WSOutboundMessageSchema: {
                             voiceCues: import("zod").ZodOptional<import("zod").ZodObject<{
                                 join: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                                 thinking: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                                waiting: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                                 done: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                             }, import("zod/v4/core").$loose>>;
                         }, import("zod/v4/core").$loose>>>;
@@ -3666,6 +3667,7 @@ export declare const WSOutboundMessageSchema: {
                             voiceCues: import("zod").ZodOptional<import("zod").ZodObject<{
                                 join: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                                 thinking: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                                waiting: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                                 done: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                             }, import("zod/v4/core").$loose>>;
                         }, import("zod/v4/core").$loose>>>;
@@ -3751,6 +3753,7 @@ export declare const WSOutboundMessageSchema: {
                 cues: import("zod").ZodOptional<import("zod").ZodObject<{
                     join: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                     thinking: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                    waiting: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                     done: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
                 }, import("zod/v4/core").$loose>>;
                 error: import("zod").ZodOptional<import("zod").ZodString>;
@@ -4816,6 +4819,156 @@ export declare const WSOutboundMessageSchema: {
                     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.git.get_file_history.response">;
+            payload: import("zod").ZodObject<{
+                cwd: import("zod").ZodString;
+                path: import("zod").ZodString;
+                entries: import("zod").ZodArray<import("zod").ZodObject<{
+                    sha: import("zod").ZodString;
+                    shortSha: import("zod").ZodString;
+                    subject: import("zod").ZodString;
+                    body: import("zod").ZodString;
+                    authorName: import("zod").ZodString;
+                    authorEmail: import("zod").ZodString;
+                    authoredAt: import("zod").ZodNumber;
+                    committerName: import("zod").ZodString;
+                    committedAt: import("zod").ZodNumber;
+                    path: import("zod").ZodString;
+                    previousPath: import("zod").ZodOptional<import("zod").ZodString>;
+                    changeKind: import("zod").ZodOptional<import("zod").ZodString>;
+                    isMerge: import("zod").ZodBoolean;
+                    parentShas: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>>;
+                hasMore: import("zod").ZodBoolean;
+                error: import("zod").ZodNullable<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"not_git_repo">;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"invalid_path">;
+                    detail: import("zod").ZodString;
+                }, 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_file_commit_diff.response">;
+            payload: import("zod").ZodObject<{
+                cwd: import("zod").ZodString;
+                path: import("zod").ZodString;
+                sha: import("zod").ZodString;
+                diff: import("zod").ZodString;
+                structured: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                    path: import("zod").ZodString;
+                    isNew: import("zod").ZodBoolean;
+                    isDeleted: import("zod").ZodBoolean;
+                    additions: import("zod").ZodNumber;
+                    deletions: import("zod").ZodNumber;
+                    hunks: import("zod").ZodArray<import("zod").ZodObject<{
+                        oldStart: import("zod").ZodNumber;
+                        oldCount: import("zod").ZodNumber;
+                        newStart: import("zod").ZodNumber;
+                        newCount: import("zod").ZodNumber;
+                        lines: import("zod").ZodArray<import("zod").ZodObject<{
+                            type: import("zod").ZodEnum<{
+                                context: "context";
+                                add: "add";
+                                remove: "remove";
+                                header: "header";
+                            }>;
+                            content: import("zod").ZodString;
+                            tokens: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                                text: import("zod").ZodString;
+                                style: import("zod").ZodNullable<import("zod").ZodString>;
+                            }, import("zod/v4/core").$strip>>>;
+                        }, import("zod/v4/core").$strip>>;
+                    }, import("zod/v4/core").$strip>>;
+                    status: import("zod").ZodOptional<import("zod").ZodEnum<{
+                        ok: "ok";
+                        too_large: "too_large";
+                        binary: "binary";
+                    }>>;
+                }, import("zod/v4/core").$strip>>>;
+                previousSha: import("zod").ZodOptional<import("zod").ZodString>;
+                previousPath: import("zod").ZodOptional<import("zod").ZodString>;
+                truncated: import("zod").ZodBoolean;
+                error: import("zod").ZodNullable<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"not_git_repo">;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"invalid_path">;
+                    detail: import("zod").ZodString;
+                }, 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_file_blame.response">;
+            payload: import("zod").ZodObject<{
+                cwd: import("zod").ZodString;
+                path: import("zod").ZodString;
+                lines: import("zod").ZodArray<import("zod").ZodObject<{
+                    line: import("zod").ZodNumber;
+                    sha: import("zod").ZodString;
+                    originalLine: import("zod").ZodNumber;
+                }, import("zod/v4/core").$strip>>;
+                commits: import("zod").ZodArray<import("zod").ZodObject<{
+                    sha: import("zod").ZodString;
+                    shortSha: import("zod").ZodString;
+                    summary: import("zod").ZodString;
+                    authorName: import("zod").ZodString;
+                    authorEmail: import("zod").ZodString;
+                    authoredAt: import("zod").ZodNumber;
+                    path: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+                startLine: import("zod").ZodNumber;
+                endLine: import("zod").ZodNumber;
+                reachedEndOfFile: import("zod").ZodBoolean;
+                error: import("zod").ZodNullable<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"not_git_repo">;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"invalid_path">;
+                    detail: import("zod").ZodString;
+                }, 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_file_origin.response">;
+            payload: import("zod").ZodObject<{
+                cwd: import("zod").ZodString;
+                path: import("zod").ZodString;
+                entry: import("zod").ZodNullable<import("zod").ZodObject<{
+                    sha: import("zod").ZodString;
+                    shortSha: import("zod").ZodString;
+                    subject: import("zod").ZodString;
+                    body: import("zod").ZodString;
+                    authorName: import("zod").ZodString;
+                    authorEmail: import("zod").ZodString;
+                    authoredAt: import("zod").ZodNumber;
+                    committerName: import("zod").ZodString;
+                    committedAt: import("zod").ZodNumber;
+                    path: import("zod").ZodString;
+                    previousPath: import("zod").ZodOptional<import("zod").ZodString>;
+                    changeKind: import("zod").ZodOptional<import("zod").ZodString>;
+                    isMerge: import("zod").ZodBoolean;
+                    parentShas: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+                }, import("zod/v4/core").$strip>>;
+                error: import("zod").ZodNullable<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"not_git_repo">;
+                }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                    kind: import("zod").ZodLiteral<"invalid_path">;
+                    detail: import("zod").ZodString;
+                }, 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<"runs.get_snapshot.response">;
             payload: import("zod").ZodObject<{

package/package.json

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