bug

1@@ -0,0 +1,2 @@
2+bin/
3+.devbox

 1@@ -0,0 +1,9 @@
 2+This is an alternative CLI for the [git-bug](https://github.com/git-bug/git-bug) library. Invoke REQUIRED SKILL **superpowers** when working on features in this application.
 3+
 4+The `bug` application uses Cobra for handling subcommands. Always recommend the minimum nesting of subcommands to accomplish the goal so that the API is easier for users to understand.  **GOOD**: `bug new`.  **BAD**: `bug issue new` = too many levels of subcommands.
 5+
 6+Use TDD. Break up large files into smaller, cohesive units that implement an operation, i.e., one file for each subcommand, with shared functionality in a separate file that deals with a particular entity type, such as an issue, comment, or identity.
 7+
 8+Use descriptive error messages meant for the user -- **THINK** = what steps does the user need to take to accomplish the command successfully.  Provide guidance on what to do next, not details about the internal structure of the application.
 9+
10+The application uses two different APIs - one suitable for a human = `bug new`, `bug edit`, `bug comment`, `bug read`, etc. These should be lenient and help the user achieve their intent.  There is a separate API nested under `bug agent` that has similar functionality but is more strict, suitable for use by an agent to collaborate with the user.  When new features are added, update README.md with instructions for the human and SKILL.md with instructions for the agent.

 1@@ -0,0 +1,61 @@
 2+
 3+build: clean
 4+	@if command -v nix >/dev/null 2>&1; then \
 5+		echo "Building with nix..."; \
 6+		nix build; \
 7+	else \
 8+		echo "Building with go..."; \
 9+		mkdir -p result/bin; \
10+		go build -o result/bin/bug *.go; \
11+	fi
12+.PHONY: build
13+
14+clean:
15+	@# Remove result directory/symlink
16+	@rm -rf result
17+	@rm -rf bin/
18+.PHONY: clean
19+
20+fmt:
21+	go fmt ./...
22+.PHONY: fmt
23+
24+lint:
25+	golangci-lint run
26+.PHONY: lint
27+
28+test:
29+	go test ./...
30+.PHONY: test
31+
32+# Update flake.nix vendorHash when go.mod/go.sum changes
33+# This target depends on go.mod and go.sum, so it will only run when they change
34+update-vendor-hash: flake.nix go.mod go.sum
35+	@echo "Checking if vendorHash needs update..."
36+	@nix build 2>&1 | tee /tmp/nix-build.log; \
37+	if grep -q "hash mismatch" /tmp/nix-build.log; then \
38+		NEW_HASH=$$(grep "got:" /tmp/nix-build.log | sed 's/.*got: *//' | tail -1); \
39+		echo "Updating vendorHash to $$NEW_HASH"; \
40+		sed -i "s|vendorHash = \"sha256-[^\"]*\";|vendorHash = \"$$NEW_HASH\";|" flake.nix; \
41+		sed -i "s|vendorHash = pkgs.lib.fakeHash;|vendorHash = \"$$NEW_HASH\";|" flake.nix; \
42+	elif grep -q "error:.*fakeHash" /tmp/nix-build.log; then \
43+		NEW_HASH=$$(grep "got:" /tmp/nix-build.log | sed 's/.*got: *//' | tail -1); \
44+		echo "Updating vendorHash to $$NEW_HASH"; \
45+		sed -i "s|vendorHash = pkgs.lib.fakeHash;|vendorHash = \"$$NEW_HASH\";|" flake.nix; \
46+	else \
47+		echo "vendorHash is up to date"; \
48+	fi
49+	@rm -f /tmp/nix-build.log
50+	@touch update-vendor-hash
51+.PHONY: update-vendor-hash
52+
53+# Update flake.lock when flake.nix inputs change
54+update-flake-lock: flake.nix
55+	nix flake lock
56+	touch update-flake-lock
57+.PHONY: update-flake-lock
58+
59+# Update both vendor hash and flake lock
60+update-flake: update-vendor-hash update-flake-lock
61+	@echo "Flake updated successfully"
62+.PHONY: update-flake

  1@@ -0,0 +1,161 @@
  2+# Bug CLI Tool
  3+
  4+A simplified CLI interface for [git-bug](https://github.com/git-bug/git-bug) issue tracking. Git-bug has its own CLI, but it's not intuitive to use.  This project implements an alternative API that is suitable for a user and an agent to use git-bug to collaborate on issues, while staying fully compatible with the original git-bug.
  5+
  6+## Quick Start
  7+
  8+Initialize git-bug in your repository:
  9+```bash
 10+bug init
 11+```
 12+
 13+This creates user and agent identities and configures git remotes for syncing bugs. Unlike git-bug, this sets up refspecs for remote tracking of bug references and identities.  You no longer need to `git push` and then `git-bug push`.  A simple `git push` or `git fetch` will also update tracked bugs.
 14+
 15+## Commands
 16+
 17+### List Issues
 18+
 19+Display all issues in a formatted table:
 20+```bash
 21+bug list              # List all open issues
 22+bug ls                # Same as above (alias)
 23+```
 24+
 25+**Filtering:**
 26+```bash
 27+bug list --filter label:bug              # Show only issues with label "bug"
 28+bug list --filter label:bug,critical     # Show issues with both labels
 29+bug list --filter age:<10d               # Show issues newer than 10 days
 30+bug list --filter age:>30d               # Show issues older than 30 days
 31+```
 32+
 33+**Sorting:**
 34+```bash
 35+bug list --sort id:asc                   # Sort by ID ascending
 36+bug list --sort id:desc                  # Sort by ID descending
 37+bug list --sort age:asc                  # Sort by age, oldest first
 38+bug list --sort age:desc                 # Sort by age, newest first (default)
 39+```
 40+
 41+**Status:**
 42+```bash
 43+bug list --status open                   # Show only open issues (default)
 44+bug list --status closed                 # Show only closed issues
 45+bug list --status all                    # Show all issues
 46+```
 47+
 48+### Create a New Issue
 49+
 50+**Using flags:**
 51+```bash
 52+bug new --title "Bug title" --message "Detailed description"
 53+bug new -t "Bug title" -m "Detailed description"
 54+```
 55+
 56+**Interactively (opens editor):**
 57+```bash
 58+bug new
 59+```
 60+
 61+The editor opens with a template. The first non-empty line becomes the title, and the rest becomes the description. Lines starting with `;;` are ignored.
 62+
 63+### Read/Show an Issue
 64+
 65+Display an issue with all its metadata and comments:
 66+```bash
 67+bug read abc1234              # Display bug with ID prefix abc1234
 68+bug show abc1234              # Same as above (alias)
 69+bug read --repo /path abc1234 # Display bug from specific repository
 70+```
 71+
 72+Output includes:
 73+- Title, Author, Creation date, Status, Labels
 74+- Description (first comment)
 75+- All additional comments with their IDs
 76+
 77+### Add a Comment
 78+
 79+**Using flags:**
 80+```bash
 81+bug comment abc1234 --message "This is my comment"
 82+bug comment abc1234 -m "This is my comment"
 83+```
 84+
 85+**Interactively (opens editor):**
 86+```bash
 87+bug comment abc1234
 88+```
 89+
 90+### Edit an Issue or Comment
 91+
 92+**Edit an issue:**
 93+```bash
 94+bug edit abc1234                    # Open editor with current content
 95+bug edit abc1234 -t "New Title"     # Update only the title
 96+bug edit abc1234 -m "New desc"      # Update only the description
 97+bug edit abc1234 -t "Title" -m "Desc"  # Update both
 98+```
 99+
100+**Edit a comment:**
101+```bash
102+bug edit def5678                    # Open editor with current comment text
103+bug edit def5678 -m "New text"      # Update the comment
104+```
105+
106+When using the editor:
107+- For issues: title on first line, blank line, then description
108+- For comments: edit the comment text directly
109+- Lines starting with `;;` are ignored (instructions)
110+
111+### Open/Close Issues
112+
113+**Open a closed issue:**
114+```bash
115+bug open abc1234
116+```
117+
118+**Close an open issue:**
119+```bash
120+bug close abc1234
121+```
122+
123+### Remove an Issue
124+
125+**WARNING: This action is permanent and cannot be undone.**
126+
127+```bash
128+bug rm abc1234                    # Remove bug with short ID
129+bug rm abc1234567890abcdef        # Remove bug with full ID
130+bug remove abc1234                # Same as above (alias)
131+```
132+
133+Note: Individual comments cannot be removed. Use `bug rm <bug-id>` to remove the entire issue including all comments.
134+
135+## IDs: Short vs Full
136+
137+Bug IDs are 64-character hex strings, but the CLI accepts shortened prefixes:
138+
139+- **Short ID**: First 7 characters (e.g., `abc1234`)
140+- **Full ID**: Complete 64-character ID
141+
142+Commands automatically resolve short IDs to full IDs. Use short IDs for convenience when interacting with bugs.
143+
144+## Working with a Repository in a Different Location
145+
146+All commands accept a `--repo` flag:
147+```bash
148+bug --repo /path/to/repo list
149+bug --repo /path/to/repo new --title "Title" --message "Message"
150+```
151+
152+By default, commands operate on the current directory (`.`).
153+
154+## Agent Collaboration
155+
156+This tool supports agent collaboration. Agents use commands under `bug agent` which are designed for non-interactive use. See SKILL.md for agent-specific documentation.  Copy the SKILL.md to `~/.agents/skills/working-with-bug`. It is designed for use with superpowers skills if colocated in `~/.agents/skills/superpowers/working-with-bug`.
157+
158+A typical flow is to define a complicated prompt in a git-bug issue, then tell the agent to `read bug [bugID] and come up with a plan`. It will then use the skill in coordination with the `superpowers/writing-plans` and `superpowers/executing-plans` skills to document its plan as a comment on the bug.  It will also add a summary after completion of development as a comment on the bug.  I like this workflow better because it retains information about which prompts/bugs led to which plans in a way that the typical superpowers flow of a `docs/plans` folder full of random markdown plans does not.
159+
160+## Syncing Bugs
161+
162+After `bug init`, git is configured to automatically sync bugs and identities when you push/fetch from the `origin` remote. Bugs are stored in git refs and will be synchronized with your team.

  1@@ -0,0 +1,308 @@
  2+---
  3+name: working-with-bug
  4+description: Use when collaborating with humans using the bug CLI tool to track and resolve issues
  5+---
  6+
  7+# Bug CLI Agent Collaboration
  8+
  9+## Overview
 10+
 11+The `bug` CLI tool provides a dual API for issue tracking:
 12+- **Human API** (`bug new`, `bug read`, etc.): Lenient, interactive, designed for human use
 13+- **Agent API** (`bug agent new`, `bug agent read`, etc.): Strict, non-interactive, designed for automation
 14+
 15+**Core principle:** Always use commands under `bug agent` when acting as an agent. These commands are non-interactive, require explicit flags, and use the agent identity created during `bug init`.
 16+
 17+**Announce at start:** "I'm using the bug-cli-agent skill to collaborate on this issue."
 18+
 19+## Typical Collaboration Workflow
 20+
 21+When a user asks you to work on a bug, follow this workflow:
 22+
 23+### Step 1: Read the Bug
 24+
 25+Use `bug agent read [bugID]` to fetch the bug details and all existing comments (which may include a previously documented plan):
 26+
 27+```bash
 28+bug agent read abc1234
 29+```
 30+
 31+**Important:** Use `bug agent read`, not `bug read`. The agent version is non-interactive and returns structured output suitable for parsing.
 32+
 33+### Step 2: Create an Implementation Plan
 34+
 35+**REQUIRED SUB-SKILL:** Invoke `superpowers:writing-plans` to create a comprehensive implementation plan.
 36+
 37+```
 38+Announce: "I'm using superpowers:writing-plans to create an implementation plan."
 39+```
 40+
 41+This will generate a detailed, bite-sized plan for resolving the bug.
 42+
 43+### Step 3: Document the Plan as a Comment
 44+
 45+Save the plan to the bug by adding it as a comment. Plans should be written in raw markdown format:
 46+
 47+```bash
 48+bug agent comment abc1234 --message "## Implementation Plan
 49+
 50+### Task 1: [Component Name]
 51+**Files:**
 52+- Create: path/to/file.ts
 53+- Test: path/to/test.ts
 54+
 55+**Step 1: Write the failing test**
 56+[code example]
 57+
 58+**Step 2: Run test to verify it fails**
 59+Run: command
 60+Expected: output"
 61+```
 62+
 63+For multi-line plans, the message flag accepts the full markdown content.
 64+
 65+### Step 4: Execute the Plan
 66+
 67+When ready to implement:
 68+
 69+1. **Read the bug again** to get the plan from the comments:
 70+   ```bash
 71+   bug agent read abc1234
 72+   ```
 73+
 74+2. **REQUIRED SUB-SKILL:** Invoke `superpowers:executing-plans` to execute the plan task-by-task:
 75+   ```
 76+   Announce: "I'm using superpowers:executing-plans to implement the documented plan."
 77+   ```
 78+
 79+3. **Update the bug** when work is complete with a summary of what was done using `bug agent comment`.
 80+
 81+4. **Do not close the bug** until the user checks the implementation and tells you to do so. Then use:
 82+   ```bash
 83+   bug agent close abc1234
 84+   ```
 85+
 86+## Agent API Reference
 87+
 88+All agent commands are non-interactive and require explicit flags. They use the agent identity (name: "agent", created during `bug init`).
 89+
 90+### bug agent read [bugID]
 91+
 92+Display a bug/issue and all its comments.
 93+
 94+```bash
 95+bug agent read abc1234
 96+```
 97+
 98+**Output includes:**
 99+- Title, Author, Creation date, Status, Labels
100+- Description (first comment)
101+- All additional comments with their IDs
102+
103+**Use this to:**
104+- Fetch bug details for analysis
105+- Retrieve documented plans from comments
106+- Check current status before acting
107+
108+### bug agent new --title "..." --message "..."
109+
110+Create a new bug/issue as the agent.
111+
112+```bash
113+bug agent new --title "CI Failure" --message "Build failed on commit abc123"
114+```
115+
116+**Required flags:**
117+- `--title`: Issue title
118+- `--message`: Issue description
119+
120+**Both flags are required.** This command is strictly non-interactive.
121+
122+### bug agent comment [bugID] --message "..."
123+
124+Add a comment to an existing bug.
125+
126+```bash
127+bug agent comment abc1234 --message "Automated analysis complete"
128+```
129+
130+**Required flag:**
131+- `--message`: Comment text (supports markdown)
132+
133+**Use this to:**
134+- Document implementation plans
135+- Add progress updates
136+- Record findings or analysis results
137+
138+**Tip:** For multi-line plans, write the markdown content directly after `--message`. The shell handles line breaks appropriately.
139+
140+### bug agent edit [bugID] --title "..." --message "..."
141+
142+Edit an issue's title and/or description.
143+
144+```bash
145+bug agent edit abc1234 --title "New Title"
146+bug agent edit abc1234 --message "New description"
147+bug agent edit abc1234 --title "Title" --message "Description"
148+```
149+
150+**Flags (at least one required):**
151+- `--title`: New issue title
152+- `--message`: New issue description
153+
154+**Note:** When editing bugs, at least one of `--title` or `--message` must be provided.
155+
156+### bug agent edit [commentID] --message "..."
157+
158+Edit an existing comment.
159+
160+```bash
161+bug agent edit def5678 --message "Updated comment text"
162+```
163+
164+**Required flag:**
165+- `--message`: New comment text
166+
167+**Important:** Comments have no title field. Only `--message` is accepted when editing a comment ID.
168+
169+### bug agent open [bugID]
170+
171+Open a closed bug/issue.
172+
173+```bash
174+bug agent open abc1234
175+```
176+
177+### bug agent close [bugID]
178+
179+Close an open bug/issue.
180+
181+```bash
182+bug agent close abc1234
183+```
184+
185+Use this when the issue is resolved.
186+
187+### bug agent rm [bugID]
188+
189+Remove a bug/issue.
190+
191+```bash
192+bug agent rm abc1234
193+bug agent remove abc1234
194+```
195+
196+**WARNING: This action is permanent.**
197+
198+**Note:** Individual comments cannot be removed. Use this to remove the entire issue.
199+
200+## Important Notes
201+
202+### Agent Identity
203+
204+The agent identity is created during `bug init` with:
205+- Name: "agent"
206+- Email: "" (empty)
207+
208+All `bug agent` commands use this identity. Do not attempt to create or modify the agent identity.
209+
210+### ID Formats
211+
212+Bug IDs are 64-character hex strings. The CLI accepts shortened prefixes:
213+- **Short ID**: First 7 characters (e.g., `abc1234`)
214+- **Full ID**: Complete 64-character ID
215+
216+Both formats work with all commands. Short IDs are preferred for convenience.
217+
218+### Working with a Repository in a Different Location
219+
220+All commands accept a `--repo` flag:
221+```bash
222+bug agent --repo /path/to/repo read abc1234
223+bug agent --repo /path/to/repo comment abc1234 --message "Update"
224+```
225+
226+By default, commands operate on the current directory (`.`).
227+
228+### Comment IDs vs Bug IDs
229+
230+When editing:
231+- **Bug IDs** (e.g., `abc1234`) refer to the entire issue
232+- **Comment IDs** (e.g., `def5678`) refer to individual comments
233+
234+The `bug agent edit` command automatically detects the type and behaves accordingly:
235+- For bugs: accepts `--title` and/or `--message`
236+- For comments: accepts only `--message`
237+
238+## Complete Workflow Example
239+
240+**Scenario:** User asks "Can you fix the bug with ID abc1234?"
241+
242+```bash
243+# Step 1: Read the bug
244+bug agent read abc1234
245+
246+# Output shows:
247+# Title: Memory leak in data processor
248+# Author: [email protected]
249+# Status: open
250+# Description: The data processor leaks memory when processing large files...
251+
252+# Step 2: Invoke writing-plans skill
253+Announce: "I'm using superpowers:writing-plans to create an implementation plan."
254+
255+# Step 3: Document the plan as a comment
256+bug agent comment abc1234 --message "## Fix: Memory leak in data processor
257+
258+### Task 1: Add failing test
259+**Files:**
260+- Create: test/memory_test.go
261+- Test: TestMemoryLeak
262+
263+**Step 1: Write failing test**
264+[code]
265+
266+**Step 2: Verify test fails**
267+Run: go test -v ./test
268+Expected: FAIL: memory leak detected
269+
270+### Task 2: Implement fix
271+..."
272+
273+# Step 4: When ready to execute, read the bug again
274+bug agent read abc1234
275+
276+# Step 5: Invoke executing-plans skill
277+Announce: "I'm using superpowers:executing-plans to implement the documented plan."
278+
279+# Step 6: Add progress comments as needed
280+bug agent comment abc1234 --message "Task 1 complete: Added failing test in commit abc1234"
281+
282+# Step 7: Close the bug when complete
283+bug agent close abc1234
284+```
285+
286+## Integration with Superpowers Skills
287+
288+**REQUIRED SUB-SKILLS:**
289+
290+- **superpowers:writing-plans** - REQUIRED for creating implementation plans
291+  - Creates bite-sized, detailed tasks
292+  - Documents exact files, code, and verification steps
293+  - Use when analyzing a bug before implementing
294+
295+- **superpowers:executing-plans** - REQUIRED for implementing documented plans
296+  - Executes tasks in batches with review checkpoints
297+  - Follows the plan exactly as documented in bug comments
298+  - Use when implementing a plan previously documented on a bug
299+
300+## Error Handling
301+
302+If a command fails:
303+
304+1. **Read the error message** - it includes guidance on what to do next
305+2. **Common issues:**
306+   - "agent identity not found" → Run `bug init` first
307+   - "failed to resolve bug ID" → Check the ID is correct
308+   - "title/message cannot be empty" → Ensure required flags are provided
309+3. **Use `bug agent read`** to verify the current state before retrying

  1@@ -0,0 +1,493 @@
  2+//go:build integration
  3+
  4+package main
  5+
  6+import (
  7+	"os/exec"
  8+	"strings"
  9+	"testing"
 10+
 11+	"github.com/git-bug/git-bug/entities/bug"
 12+	"github.com/git-bug/git-bug/entity"
 13+	"github.com/git-bug/git-bug/repository"
 14+)
 15+
 16+// TestAgentCommentCommand_WithFlag adds a comment as agent using the message flag
 17+func TestAgentCommentCommand_WithFlag(t *testing.T) {
 18+	tmpDir := t.TempDir()
 19+
 20+	// Initialize a git repo
 21+	initCmd := exec.Command("git", "init")
 22+	initCmd.Dir = tmpDir
 23+	if err := initCmd.Run(); err != nil {
 24+		t.Fatalf("failed to init git repo: %v", err)
 25+	}
 26+
 27+	// Initialize git-bug with both user and agent identities
 28+	if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
 29+		t.Fatalf("failed to create user identity: %v", err)
 30+	}
 31+	if err := createIdentity(tmpDir, "agent", "", false); err != nil {
 32+		t.Fatalf("failed to create agent identity: %v", err)
 33+	}
 34+
 35+	// Create a bug first as user
 36+	title := "Test Bug for Agent Comment"
 37+	message := "Initial bug description"
 38+	if err := runNew(tmpDir, title, message); err != nil {
 39+		t.Fatalf("runNew failed: %v", err)
 40+	}
 41+
 42+	// Get the bug ID
 43+	repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
 44+	if err != nil {
 45+		t.Fatalf("failed to open repo: %v", err)
 46+	}
 47+
 48+	var bugID string
 49+	for streamedBug := range bug.ReadAll(repo) {
 50+		if streamedBug.Err != nil {
 51+			t.Fatalf("failed to read bug: %v", streamedBug.Err)
 52+		}
 53+		b := streamedBug.Entity
 54+		snap := b.Compile()
 55+		if snap.Title == title {
 56+			bugID = b.Id().String()
 57+			break
 58+		}
 59+	}
 60+	repo.Close()
 61+
 62+	if bugID == "" {
 63+		t.Fatal("could not find created bug")
 64+	}
 65+
 66+	// Add a comment as agent using the flag
 67+	commentText := "This is an automated agent comment"
 68+	if err := runAgentComment(tmpDir, bugID, commentText); err != nil {
 69+		t.Fatalf("runAgentComment failed: %v", err)
 70+	}
 71+
 72+	// Verify comment was added with agent as author
 73+	repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
 74+	if err != nil {
 75+		t.Fatalf("failed to open repo: %v", err)
 76+	}
 77+	defer repo.Close()
 78+
 79+	b, err := bug.Read(repo, entity.Id(bugID))
 80+	if err != nil {
 81+		t.Fatalf("failed to read bug: %v", err)
 82+	}
 83+
 84+	snap := b.Compile()
 85+	if len(snap.Comments) != 2 {
 86+		t.Errorf("expected 2 comments (original + new), got %d", len(snap.Comments))
 87+	}
 88+
 89+	// Check the second comment (index 1) is our agent comment
 90+	if snap.Comments[1].Message != commentText {
 91+		t.Errorf("comment message = %q, want %q", snap.Comments[1].Message, commentText)
 92+	}
 93+
 94+	if snap.Comments[1].Author.Name() != "agent" {
 95+		t.Errorf("comment author = %q, want %q", snap.Comments[1].Author.Name(), "agent")
 96+	}
 97+
 98+	if snap.Comments[1].Author.Email() != "" {
 99+		t.Errorf("comment author email = %q, want empty", snap.Comments[1].Author.Email())
100+	}
101+}
102+
103+// TestAgentCommentCommand_WithShortID adds a comment as agent using short bug ID
104+func TestAgentCommentCommand_WithShortID(t *testing.T) {
105+	tmpDir := t.TempDir()
106+
107+	// Initialize a git repo
108+	initCmd := exec.Command("git", "init")
109+	initCmd.Dir = tmpDir
110+	if err := initCmd.Run(); err != nil {
111+		t.Fatalf("failed to init git repo: %v", err)
112+	}
113+
114+	// Initialize identities
115+	if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
116+		t.Fatalf("failed to create user identity: %v", err)
117+	}
118+	if err := createIdentity(tmpDir, "agent", "", false); err != nil {
119+		t.Fatalf("failed to create agent identity: %v", err)
120+	}
121+
122+	// Create a bug
123+	title := "Test Bug for Agent Short ID"
124+	if err := runNew(tmpDir, title, ""); err != nil {
125+		t.Fatalf("runNew failed: %v", err)
126+	}
127+
128+	// Get the bug ID and short ID
129+	repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
130+	if err != nil {
131+		t.Fatalf("failed to open repo: %v", err)
132+	}
133+
134+	var bugID, shortID string
135+	for streamedBug := range bug.ReadAll(repo) {
136+		if streamedBug.Err != nil {
137+			t.Fatalf("failed to read bug: %v", streamedBug.Err)
138+		}
139+		b := streamedBug.Entity
140+		snap := b.Compile()
141+		if snap.Title == title {
142+			bugID = b.Id().String()
143+			if len(bugID) > 7 {
144+				shortID = bugID[:7]
145+			} else {
146+				shortID = bugID
147+			}
148+			break
149+		}
150+	}
151+	repo.Close()
152+
153+	if shortID == "" {
154+		t.Fatal("could not find created bug")
155+	}
156+
157+	// Add a comment as agent using short ID
158+	commentText := "Agent comment via short ID"
159+	if err := runAgentComment(tmpDir, shortID, commentText); err != nil {
160+		t.Fatalf("runAgentComment with short ID failed: %v", err)
161+	}
162+
163+	// Verify comment was added
164+	repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
165+	if err != nil {
166+		t.Fatalf("failed to open repo: %v", err)
167+	}
168+	defer repo.Close()
169+
170+	b, err := bug.Read(repo, entity.Id(bugID))
171+	if err != nil {
172+		t.Fatalf("failed to read bug: %v", err)
173+	}
174+
175+	snap := b.Compile()
176+	if len(snap.Comments) != 2 {
177+		t.Errorf("expected 2 comments, got %d", len(snap.Comments))
178+	}
179+
180+	if snap.Comments[1].Message != commentText {
181+		t.Errorf("comment message = %q, want %q", snap.Comments[1].Message, commentText)
182+	}
183+
184+	if snap.Comments[1].Author.Name() != "agent" {
185+		t.Errorf("comment author = %q, want %q", snap.Comments[1].Author.Name(), "agent")
186+	}
187+}
188+
189+// TestAgentCommentCommand_MissingAgentIdentity tests error when agent not initialized
190+func TestAgentCommentCommand_MissingAgentIdentity(t *testing.T) {
191+	tmpDir := t.TempDir()
192+
193+	// Initialize a git repo
194+	initCmd := exec.Command("git", "init")
195+	initCmd.Dir = tmpDir
196+	if err := initCmd.Run(); err != nil {
197+		t.Fatalf("failed to init git repo: %v", err)
198+	}
199+
200+	// Only create user identity, NOT agent
201+	if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
202+		t.Fatalf("failed to create user identity: %v", err)
203+	}
204+
205+	// Create a bug as user
206+	title := "Test Bug"
207+	if err := runNew(tmpDir, title, ""); err != nil {
208+		t.Fatalf("runNew failed: %v", err)
209+	}
210+
211+	// Get the bug ID
212+	repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
213+	if err != nil {
214+		t.Fatalf("failed to open repo: %v", err)
215+	}
216+
217+	var bugID string
218+	for streamedBug := range bug.ReadAll(repo) {
219+		if streamedBug.Err != nil {
220+			t.Fatalf("failed to read bug: %v", streamedBug.Err)
221+		}
222+		b := streamedBug.Entity
223+		snap := b.Compile()
224+		if snap.Title == title {
225+			bugID = b.Id().String()
226+			break
227+		}
228+	}
229+	repo.Close()
230+
231+	// Try to add a comment as agent (should fail)
232+	err = runAgentComment(tmpDir, bugID, "Test comment")
233+	if err == nil {
234+		t.Error("expected error when agent identity not found, got nil")
235+	}
236+
237+	if !strings.Contains(err.Error(), "agent identity not found") {
238+		t.Errorf("expected 'agent identity not found' error, got: %v", err)
239+	}
240+}
241+
242+// TestAgentCommentCommand_EmptyMessageError tests error for empty message
243+func TestAgentCommentCommand_EmptyMessageError(t *testing.T) {
244+	tmpDir := t.TempDir()
245+
246+	// Initialize a git repo
247+	initCmd := exec.Command("git", "init")
248+	initCmd.Dir = tmpDir
249+	if err := initCmd.Run(); err != nil {
250+		t.Fatalf("failed to init git repo: %v", err)
251+	}
252+
253+	// Initialize identities
254+	if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
255+		t.Fatalf("failed to create user identity: %v", err)
256+	}
257+	if err := createIdentity(tmpDir, "agent", "", false); err != nil {
258+		t.Fatalf("failed to create agent identity: %v", err)
259+	}
260+
261+	// Create a bug
262+	title := "Test Bug"
263+	if err := runNew(tmpDir, title, ""); err != nil {
264+		t.Fatalf("runNew failed: %v", err)
265+	}
266+
267+	// Get the bug ID
268+	repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
269+	if err != nil {
270+		t.Fatalf("failed to open repo: %v", err)
271+	}
272+
273+	var bugID string
274+	for streamedBug := range bug.ReadAll(repo) {
275+		if streamedBug.Err != nil {
276+			t.Fatalf("failed to read bug: %v", streamedBug.Err)
277+		}
278+		b := streamedBug.Entity
279+		snap := b.Compile()
280+		if snap.Title == title {
281+			bugID = b.Id().String()
282+			break
283+		}
284+	}
285+	repo.Close()
286+
287+	// Try with empty message
288+	err = runAgentComment(tmpDir, bugID, "   ")
289+	if err == nil {
290+		t.Error("expected error for empty message, got nil")
291+	}
292+
293+	if !strings.Contains(err.Error(), "message cannot be empty") {
294+		t.Errorf("expected 'message cannot be empty' error, got: %v", err)
295+	}
296+}
297+
298+// TestAgentCommentCommand_InvalidBugID tests error for invalid bug ID
299+func TestAgentCommentCommand_InvalidBugID(t *testing.T) {
300+	tmpDir := t.TempDir()
301+
302+	// Initialize a git repo
303+	initCmd := exec.Command("git", "init")
304+	initCmd.Dir = tmpDir
305+	if err := initCmd.Run(); err != nil {
306+		t.Fatalf("failed to init git repo: %v", err)
307+	}
308+
309+	// Initialize identities
310+	if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
311+		t.Fatalf("failed to create user identity: %v", err)
312+	}
313+	if err := createIdentity(tmpDir, "agent", "", false); err != nil {
314+		t.Fatalf("failed to create agent identity: %v", err)
315+	}
316+
317+	// Try to add a comment to non-existent bug
318+	err := runAgentComment(tmpDir, "nonexistent", "Test comment")
319+	if err == nil {
320+		t.Error("expected error for invalid bug ID, got nil")
321+	}
322+
323+	if !strings.Contains(err.Error(), "failed to resolve bug ID") {
324+		t.Errorf("expected 'failed to resolve bug ID' error, got: %v", err)
325+	}
326+}
327+
328+// TestAgentCommentCommand_MultipleComments tests adding multiple agent comments
329+func TestAgentCommentCommand_MultipleComments(t *testing.T) {
330+	tmpDir := t.TempDir()
331+
332+	// Initialize a git repo
333+	initCmd := exec.Command("git", "init")
334+	initCmd.Dir = tmpDir
335+	if err := initCmd.Run(); err != nil {
336+		t.Fatalf("failed to init git repo: %v", err)
337+	}
338+
339+	// Initialize identities
340+	if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
341+		t.Fatalf("failed to create user identity: %v", err)
342+	}
343+	if err := createIdentity(tmpDir, "agent", "", false); err != nil {
344+		t.Fatalf("failed to create agent identity: %v", err)
345+	}
346+
347+	// Create a bug as user
348+	title := "Test Bug for Multiple Agent Comments"
349+	if err := runNew(tmpDir, title, ""); err != nil {
350+		t.Fatalf("runNew failed: %v", err)
351+	}
352+
353+	// Get the bug ID
354+	repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
355+	if err != nil {
356+		t.Fatalf("failed to open repo: %v", err)
357+	}
358+
359+	var bugID string
360+	for streamedBug := range bug.ReadAll(repo) {
361+		if streamedBug.Err != nil {
362+			t.Fatalf("failed to read bug: %v", streamedBug.Err)
363+		}
364+		b := streamedBug.Entity
365+		snap := b.Compile()
366+		if snap.Title == title {
367+			bugID = b.Id().String()
368+			break
369+		}
370+	}
371+	repo.Close()
372+
373+	// Add multiple comments as agent
374+	comments := []string{
375+		"First agent comment",
376+		"Second agent comment",
377+		"Third agent comment with **markdown**",
378+	}
379+
380+	for _, comment := range comments {
381+		if err := runAgentComment(tmpDir, bugID, comment); err != nil {
382+			t.Fatalf("runAgentComment failed: %v", err)
383+		}
384+	}
385+
386+	// Verify all comments were added
387+	repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
388+	if err != nil {
389+		t.Fatalf("failed to open repo: %v", err)
390+	}
391+	defer repo.Close()
392+
393+	b, err := bug.Read(repo, entity.Id(bugID))
394+	if err != nil {
395+		t.Fatalf("failed to read bug: %v", err)
396+	}
397+
398+	snap := b.Compile()
399+	// Original + 3 comments = 4 total
400+	if len(snap.Comments) != 4 {
401+		t.Errorf("expected 4 comments, got %d", len(snap.Comments))
402+	}
403+
404+	// Verify each comment (index 1-3 are our added comments)
405+	for i, expected := range comments {
406+		if snap.Comments[i+1].Message != expected {
407+			t.Errorf("comment %d message = %q, want %q", i+1, snap.Comments[i+1].Message, expected)
408+		}
409+		if snap.Comments[i+1].Author.Name() != "agent" {
410+			t.Errorf("comment %d author = %q, want %q", i+1, snap.Comments[i+1].Author.Name(), "agent")
411+		}
412+	}
413+}
414+
415+// TestAgentCommentCommand_WithMarkdown tests that markdown is preserved
416+func TestAgentCommentCommand_WithMarkdown(t *testing.T) {
417+	tmpDir := t.TempDir()
418+
419+	// Initialize a git repo
420+	initCmd := exec.Command("git", "init")
421+	initCmd.Dir = tmpDir
422+	if err := initCmd.Run(); err != nil {
423+		t.Fatalf("failed to init git repo: %v", err)
424+	}
425+
426+	// Initialize identities
427+	if err := createIdentity(tmpDir, "Test User", "[email protected]", true); err != nil {
428+		t.Fatalf("failed to create user identity: %v", err)
429+	}
430+	if err := createIdentity(tmpDir, "agent", "", false); err != nil {
431+		t.Fatalf("failed to create agent identity: %v", err)
432+	}
433+
434+	// Create a bug
435+	title := "Test Bug for Markdown"
436+	if err := runNew(tmpDir, title, ""); err != nil {
437+		t.Fatalf("runNew failed: %v", err)
438+	}
439+
440+	// Get the bug ID
441+	repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
442+	if err != nil {
443+		t.Fatalf("failed to open repo: %v", err)
444+	}
445+
446+	var bugID string
447+	for streamedBug := range bug.ReadAll(repo) {
448+		if streamedBug.Err != nil {
449+			t.Fatalf("failed to read bug: %v", streamedBug.Err)
450+		}
451+		b := streamedBug.Entity
452+		snap := b.Compile()
453+		if snap.Title == title {
454+			bugID = b.Id().String()
455+			break
456+		}
457+	}
458+	repo.Close()
459+
460+	// Add a comment with markdown
461+	markdownComment := `# Analysis Report
462+
463+## Summary
464+- **Status**: PASSED
465+- **Duration**: 5m 32s
466+
467+## Details
468+All tests passed successfully.`
469+
470+	if err := runAgentComment(tmpDir, bugID, markdownComment); err != nil {
471+		t.Fatalf("runAgentComment failed: %v", err)
472+	}
473+
474+	// Verify comment was added with markdown preserved
475+	repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
476+	if err != nil {
477+		t.Fatalf("failed to open repo: %v", err)
478+	}
479+	defer repo.Close()
480+
481+	b, err := bug.Read(repo, entity.Id(bugID))
482+	if err != nil {
483+		t.Fatalf("failed to read bug: %v", err)
484+	}
485+
486+	snap := b.Compile()
487+	if len(snap.Comments) != 2 {
488+		t.Errorf("expected 2 comments, got %d", len(snap.Comments))
489+	}
490+
491+	if snap.Comments[1].Message != markdownComment {
492+		t.Errorf("comment message does not match expected markdown:\ngot:\n%s\nwant:\n%s", snap.Comments[1].Message, markdownComment)
493+	}
494+}

  1@@ -0,0 +1,400 @@
  2+//go:build integration
  3+
  4+package main
  5+
  6+import (
  7+	"os/exec"
  8+	"strings"
  9+	"testing"
 10+
 11+	"github.com/git-bug/git-bug/entities/bug"
 12+	"github.com/git-bug/git-bug/entity"
 13+	"github.com/git-bug/git-bug/repository"
 14+)
 15+
 16+// TestAgentEditCommand_EditIssue edits an issue as the agent
 17+func TestAgentEditCommand_EditIssue(t *testing.T) {
 18+	tmpDir := t.TempDir()
 19+
 20+	// Initialize a git repo
 21+	initCmd := exec.Command("git", "init")
 22+	initCmd.Dir = tmpDir
 23+	if err := initCmd.Run(); err != nil {
 24+		t.Fatalf("failed to init git repo: %v", err)
 25+	}
 26+	// Add origin remote for bug init
 27+	remoteCmd := exec.Command("git", "remote", "add", "origin", "[email protected]:test/repo.git")
 28+	remoteCmd.Dir = tmpDir
 29+	if err := remoteCmd.Run(); err != nil {
 30+		t.Fatalf("failed to add origin remote: %v", err)
 31+	}
 32+
 33+	// Initialize git-bug identities (creates both user and agent)
 34+	if err := runInitWithReader(tmpDir, strings.NewReader("Test User\[email protected]\n")); err != nil {
 35+		t.Fatalf("runInit failed: %v", err)
 36+	}
 37+
 38+	// Create a bug as agent
 39+	if err := runAgentNew(tmpDir, "Original Title", "Original description"); err != nil {
 40+		t.Fatalf("runAgentNew failed: %v", err)
 41+	}
 42+
 43+	// Get the bug ID
 44+	repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
 45+	if err != nil {
 46+		t.Fatalf("failed to open repo: %v", err)
 47+	}
 48+
 49+	var bugID string
 50+	for streamedBug := range bug.ReadAll(repo) {
 51+		if streamedBug.Err != nil {
 52+			t.Fatalf("failed to read bug: %v", streamedBug.Err)
 53+		}
 54+		b := streamedBug.Entity
 55+		snap := b.Compile()
 56+		if snap.Title == "Original Title" {
 57+			bugID = b.Id().String()
 58+			break
 59+		}
 60+	}
 61+	repo.Close()
 62+
 63+	if bugID == "" {
 64+		t.Fatal("could not find created bug")
 65+	}
 66+
 67+	// Edit as agent
 68+	newTitle := "Agent Updated Title"
 69+	newMessage := "Agent updated description"
 70+	if err := runAgentEdit(tmpDir, bugID, newTitle, newMessage); err != nil {
 71+		t.Fatalf("runAgentEdit failed: %v", err)
 72+	}
 73+
 74+	// Verify both were updated
 75+	repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
 76+	if err != nil {
 77+		t.Fatalf("failed to open repo: %v", err)
 78+	}
 79+	defer repo.Close()
 80+
 81+	b, err := bug.Read(repo, entity.Id(bugID))
 82+	if err != nil {
 83+		t.Fatalf("failed to read bug: %v", err)
 84+	}
 85+
 86+	snap := b.Compile()
 87+	if snap.Title != newTitle {
 88+		t.Errorf("title = %q, want %q", snap.Title, newTitle)
 89+	}
 90+	if len(snap.Comments) == 0 || snap.Comments[0].Message != newMessage {
 91+		t.Errorf("description = %q, want %q", snap.Comments[0].Message, newMessage)
 92+	}
 93+}
 94+
 95+// TestAgentEditCommand_EditComment edits a comment as the agent
 96+func TestAgentEditCommand_EditComment(t *testing.T) {
 97+	tmpDir := t.TempDir()
 98+
 99+	// Initialize a git repo
100+	initCmd := exec.Command("git", "init")
101+	initCmd.Dir = tmpDir
102+	if err := initCmd.Run(); err != nil {
103+		t.Fatalf("failed to init git repo: %v", err)
104+	}
105+	// Add origin remote for bug init
106+	remoteCmd := exec.Command("git", "remote", "add", "origin", "[email protected]:test/repo.git")
107+	remoteCmd.Dir = tmpDir
108+	if err := remoteCmd.Run(); err != nil {
109+		t.Fatalf("failed to add origin remote: %v", err)
110+	}
111+
112+	// Initialize git-bug identities
113+	if err := runInitWithReader(tmpDir, strings.NewReader("Test User\[email protected]\n")); err != nil {
114+		t.Fatalf("runInit failed: %v", err)
115+	}
116+
117+	// Create a bug as agent
118+	if err := runAgentNew(tmpDir, "Test Bug", "Description"); err != nil {
119+		t.Fatalf("runAgentNew failed: %v", err)
120+	}
121+
122+	// Get the bug ID
123+	repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
124+	if err != nil {
125+		t.Fatalf("failed to open repo: %v", err)
126+	}
127+
128+	var bugID string
129+	for streamedBug := range bug.ReadAll(repo) {
130+		if streamedBug.Err != nil {
131+			t.Fatalf("failed to read bug: %v", streamedBug.Err)
132+		}
133+		b := streamedBug.Entity
134+		snap := b.Compile()
135+		if snap.Title == "Test Bug" {
136+			bugID = b.Id().String()
137+			break
138+		}
139+	}
140+	repo.Close()
141+
142+	// Add a comment as agent
143+	originalComment := "Original agent comment"
144+	if err := runAgentComment(tmpDir, bugID, originalComment); err != nil {
145+		t.Fatalf("runAgentComment failed: %v", err)
146+	}
147+
148+	// Get the comment ID
149+	repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
150+	if err != nil {
151+		t.Fatalf("failed to open repo: %v", err)
152+	}
153+
154+	b, err := bug.Read(repo, entity.Id(bugID))
155+	if err != nil {
156+		t.Fatalf("failed to read bug: %v", err)
157+	}
158+	snap := b.Compile()
159+	if len(snap.Comments) < 2 {
160+		t.Fatal("expected at least 2 comments")
161+	}
162+	commentID := snap.Comments[1].CombinedId().String()
163+	repo.Close()
164+
165+	// Edit the comment as agent
166+	newComment := "Updated agent comment"
167+	if err := runAgentEdit(tmpDir, commentID, "", newComment); err != nil {
168+		t.Fatalf("runAgentEdit failed: %v", err)
169+	}
170+
171+	// Verify comment was updated
172+	repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
173+	if err != nil {
174+		t.Fatalf("failed to open repo: %v", err)
175+	}
176+	defer repo.Close()
177+
178+	b, err = bug.Read(repo, entity.Id(bugID))
179+	if err != nil {
180+		t.Fatalf("failed to read bug: %v", err)
181+	}
182+
183+	snap = b.Compile()
184+	if len(snap.Comments) < 2 {
185+		t.Fatal("expected at least 2 comments")
186+	}
187+	if snap.Comments[1].Message != newComment {
188+		t.Errorf("comment = %q, want %q", snap.Comments[1].Message, newComment)
189+	}
190+}
191+
192+// TestAgentEditCommand_RequiresMessage tests that agent edit requires at least one field
193+func TestAgentEditCommand_RequiresMessage(t *testing.T) {
194+	tmpDir := t.TempDir()
195+
196+	// Initialize a git repo
197+	initCmd := exec.Command("git", "init")
198+	initCmd.Dir = tmpDir
199+	if err := initCmd.Run(); err != nil {
200+		t.Fatalf("failed to init git repo: %v", err)
201+	}
202+	// Add origin remote for bug init
203+	remoteCmd := exec.Command("git", "remote", "add", "origin", "[email protected]:test/repo.git")
204+	remoteCmd.Dir = tmpDir
205+	if err := remoteCmd.Run(); err != nil {
206+		t.Fatalf("failed to add origin remote: %v", err)
207+	}
208+
209+	// Initialize git-bug identities
210+	if err := runInitWithReader(tmpDir, strings.NewReader("Test User\[email protected]\n")); err != nil {
211+		t.Fatalf("runInit failed: %v", err)
212+	}
213+
214+	// Create a bug as agent
215+	if err := runAgentNew(tmpDir, "Test Bug", "Description"); err != nil {
216+		t.Fatalf("runAgentNew failed: %v", err)
217+	}
218+
219+	// Get the bug ID
220+	repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
221+	if err != nil {
222+		t.Fatalf("failed to open repo: %v", err)
223+	}
224+
225+	var bugID string
226+	for streamedBug := range bug.ReadAll(repo) {
227+		if streamedBug.Err != nil {
228+			t.Fatalf("failed to read bug: %v", streamedBug.Err)
229+		}
230+		b := streamedBug.Entity
231+		snap := b.Compile()
232+		if snap.Title == "Test Bug" {
233+			bugID = b.Id().String()
234+			break
235+		}
236+	}
237+	repo.Close()
238+
239+	// Add a comment as agent
240+	if err := runAgentComment(tmpDir, bugID, "Original comment"); err != nil {
241+		t.Fatalf("runAgentComment failed: %v", err)
242+	}
243+
244+	// Get the comment ID
245+	repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
246+	if err != nil {
247+		t.Fatalf("failed to open repo: %v", err)
248+	}
249+
250+	b, err := bug.Read(repo, entity.Id(bugID))
251+	if err != nil {
252+		t.Fatalf("failed to read bug: %v", err)
253+	}
254+	snap := b.Compile()
255+	commentID := snap.Comments[1].CombinedId().String()
256+	repo.Close()
257+
258+	// Try to edit comment without message
259+	err = runAgentEdit(tmpDir, commentID, "", "")
260+	if err == nil {
261+		t.Error("expected error when editing comment without message, got nil")
262+	}
263+
264+	if !strings.Contains(err.Error(), "either --title or --message") {
265+		t.Errorf("expected 'either --title or --message' error, got: %v", err)
266+	}
267+}
268+
269+// TestAgentEditCommand_RequiresAtLeastOneField tests that agent edit requires at least one field
270+func TestAgentEditCommand_RequiresAtLeastOneField(t *testing.T) {
271+	tmpDir := t.TempDir()
272+
273+	// Initialize a git repo
274+	initCmd := exec.Command("git", "init")
275+	initCmd.Dir = tmpDir
276+	if err := initCmd.Run(); err != nil {
277+		t.Fatalf("failed to init git repo: %v", err)
278+	}
279+	// Add origin remote for bug init
280+	remoteCmd := exec.Command("git", "remote", "add", "origin", "[email protected]:test/repo.git")
281+	remoteCmd.Dir = tmpDir
282+	if err := remoteCmd.Run(); err != nil {
283+		t.Fatalf("failed to add origin remote: %v", err)
284+	}
285+
286+	// Initialize git-bug identities
287+	if err := runInitWithReader(tmpDir, strings.NewReader("Test User\[email protected]\n")); err != nil {
288+		t.Fatalf("runInit failed: %v", err)
289+	}
290+
291+	// Create a bug as agent
292+	if err := runAgentNew(tmpDir, "Test Bug", "Description"); err != nil {
293+		t.Fatalf("runAgentNew failed: %v", err)
294+	}
295+
296+	// Get the bug ID
297+	repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
298+	if err != nil {
299+		t.Fatalf("failed to open repo: %v", err)
300+	}
301+
302+	var bugID string
303+	for streamedBug := range bug.ReadAll(repo) {
304+		if streamedBug.Err != nil {
305+			t.Fatalf("failed to read bug: %v", streamedBug.Err)
306+		}
307+		b := streamedBug.Entity
308+		snap := b.Compile()
309+		if snap.Title == "Test Bug" {
310+			bugID = b.Id().String()
311+			break
312+		}
313+	}
314+	repo.Close()
315+
316+	// Try to edit without any flags
317+	err = runAgentEdit(tmpDir, bugID, "", "")
318+	if err == nil {
319+		t.Error("expected error when editing without any fields, got nil")
320+	}
321+
322+	if !strings.Contains(err.Error(), "either --title or --message") {
323+		t.Errorf("expected 'either --title or --message' error, got: %v", err)
324+	}
325+}
326+
327+// TestAgentEditCommand_OnlyTitle edits only the title as agent
328+func TestAgentEditCommand_OnlyTitle(t *testing.T) {
329+	tmpDir := t.TempDir()
330+
331+	// Initialize a git repo
332+	initCmd := exec.Command("git", "init")
333+	initCmd.Dir = tmpDir
334+	if err := initCmd.Run(); err != nil {
335+		t.Fatalf("failed to init git repo: %v", err)
336+	}
337+	// Add origin remote for bug init
338+	remoteCmd := exec.Command("git", "remote", "add", "origin", "[email protected]:test/repo.git")
339+	remoteCmd.Dir = tmpDir
340+	if err := remoteCmd.Run(); err != nil {
341+		t.Fatalf("failed to add origin remote: %v", err)
342+	}
343+
344+	// Initialize git-bug identities
345+	if err := runInitWithReader(tmpDir, strings.NewReader("Test User\[email protected]\n")); err != nil {
346+		t.Fatalf("runInit failed: %v", err)
347+	}
348+
349+	// Create a bug as agent
350+	originalTitle := "Original Title"
351+	originalDesc := "Original description"
352+	if err := runAgentNew(tmpDir, originalTitle, originalDesc); err != nil {
353+		t.Fatalf("runAgentNew failed: %v", err)
354+	}
355+
356+	// Get the bug ID
357+	repo, err := repository.OpenGoGitRepo(tmpDir, "", nil)
358+	if err != nil {
359+		t.Fatalf("failed to open repo: %v", err)
360+	}
361+
362+	var bugID string
363+	for streamedBug := range bug.ReadAll(repo) {
364+		if streamedBug.Err != nil {
365+			t.Fatalf("failed to read bug: %v", streamedBug.Err)
366+		}
367+		b := streamedBug.Entity
368+		snap := b.Compile()
369+		if snap.Title == originalTitle {
370+			bugID = b.Id().String()
371+			break
372+		}
373+	}
374+	repo.Close()
375+
376+	// Edit only title as agent
377+	newTitle := "New Title"
378+	if err := runAgentEdit(tmpDir, bugID, newTitle, ""); err != nil {
379+		t.Fatalf("runAgentEdit failed: %v", err)
380+	}
381+
382+	// Verify only title changed
383+	repo, err = repository.OpenGoGitRepo(tmpDir, "", nil)
384+	if err != nil {
385+		t.Fatalf("failed to open repo: %v", err)
386+	}
387+	defer repo.Close()
388+
389+	b, err := bug.Read(repo, entity.Id(bugID))
390+	if err != nil {
391+		t.Fatalf("failed to read bug: %v", err)
392+	}
393+
394+	snap := b.Compile()
395+	if snap.Title != newTitle {
396+		t.Errorf("title = %q, want %q", snap.Title, newTitle)
397+	}
398+	if len(snap.Comments) == 0 || snap.Comments[0].Message != originalDesc {
399+		t.Errorf("description was changed unexpectedly")
400+	}
401+}