Merge pull request #57 from illegalstudio/feat/resume-grok

fix: support resuming Grok sessions

Author: nahime0

docs/concepts/session-info.md

@@ -47,9 +47,10 @@ For agents that expose a resumable CLI, lazyagent builds the exact shell command
 - OpenCode: `opencode -s <id>`
 - Kilo: `kilo --session=<id>`
 - Cursor: `cursor-agent --resume="<id>"`
+- Grok: `grok --resume '<session-id>'`
 - Kimi Code: `kimi --resume <session-id>`
 
-Grok CLI does not currently expose a direct resume command that lazyagent can invoke, so Grok sessions omit this field. In the TUI, <kbd>c</kbd> copies the command to the clipboard when one exists. The GUI has a copy button next to the command. The API exposes it as `resume_command` on the session detail response.
+In the TUI, <kbd>c</kbd> copies the command to the clipboard when one exists. The GUI has a copy button next to the command. The API exposes it as `resume_command` on the session detail response.
 
 ## Cost estimation
 

docs/maintenance/search.md

@@ -74,12 +74,11 @@ Type a 1-based result number to open that session in the originating agent when
 | codex | `codex resume <session-id>` |
 | amp | `amp threads continue <session-id>` |
 | pi | `pi --session <session-id>` |
+| grok | `grok --resume '<session-id>'` |
 | kimi | `kimi --resume <session-id>` |
 
 The command runs from the session's original CWD when that directory still exists, otherwise from the current shell directory. Pressing <kbd>Enter</kbd> on an empty line exits without opening anything.
 
-> **Grok sessions** are indexed and searchable, but `search` cannot resume them directly — Grok exposes no resume command, so selecting a Grok result reports that and exits.
-
 ## Index management
 
 The index updates *incrementally* on every run — there's normally no reason to think about it. Two situations call for a manual rebuild:

docs/usage/cli.md

@@ -171,9 +171,9 @@ lazyagent search --agent codex "parser"
 lazyagent search --reindex "config"
 ```
 
-After printing results in an interactive terminal, `search` prompts for a result number; entering one opens that chat via the originating agent's resume command when lazyagent knows one. Grok sessions are searchable but not directly resumable, because Grok CLI does not expose a resume command. Piped output stays non-interactive.
+After printing results in an interactive terminal, `search` prompts for a result number; entering one opens that chat via the originating agent's resume command when lazyagent knows one. Grok sessions resume with `grok --resume '<session-id>'`. Piped output stays non-interactive.
 
-Full reference, including the index location, ranking, resume commands, and Grok caveat: [`search`](../maintenance/search.md).
+Full reference, including the index location, ranking, and resume commands: [`search`](../maintenance/search.md).
 
 ### `limits`
 

docs/usage/history.md

@@ -53,7 +53,7 @@ when it still exists. Pressing Enter on an empty line — or `ctrl+c` —
 quits without resuming. Piped or redirected output skips the prompt
 entirely, so `lazyagent history | cat` stays non-interactive.
 
-Agents lazyagent can exec directly: Claude Code, Codex, Amp, pi, and Kimi.
+Agents lazyagent can exec directly: Claude Code, Codex, Amp, pi, Grok, and Kimi.
 Other agents print a "no resume command" notice instead. For scripted
 output, `lazyagent sessions --json` emits the same list as JSON.
 

docs/usage/latest.md

@@ -24,7 +24,7 @@ Opening: claude --resume 3f2a…
 
 The resume command runs with this terminal attached, from the session's own
 working directory when it still exists. Agents lazyagent can exec directly:
-Claude Code, Codex, Amp, pi, and Kimi; for other agents a "no resume
+Claude Code, Codex, Amp, pi, Grok, and Kimi; for other agents a "no resume
 command" notice is printed instead. "Most recent" means latest activity in
 the transcript (lazyagent does not record a separate creation time).
 

docs/usage/sessions.md

@@ -22,7 +22,7 @@ lazyagent sessions [--agent NAME] [--json] [--dir PATH]
 ┌─ Sessions in ~/projects/foo (12) ───────────────────────────┐
 │ ▸ claude  2h ago      84  fix build embed placeholder       │
 │   codex   yesterday   31  webhook config models             │
-│   grok    3d ago      12  docs limits   (no resume)         │
+│   grok    3d ago      12  docs limits                       │
 └─────────────────────────────────────────────────────────────┘
   ↑/↓ move · enter open · c copy resume cmd · q quit
 ```
@@ -41,8 +41,8 @@ user message).
 **Opening** runs the agent's resume command (e.g. `claude --resume <id>`)
 with this terminal attached, from the session's own working directory when
 it still exists. Agents lazyagent can exec directly: Claude Code, Codex,
-Amp, pi, and Kimi. For OpenCode, Kilo, and Cursor the resume command is
-copied to the clipboard instead; Grok has no resume command.
+Amp, pi, Grok, and Kimi. For OpenCode, Kilo, and Cursor the resume command
+is copied to the clipboard instead.
 
 ## Flags
 

internal/core/resume.go

@@ -1,6 +1,9 @@
 package core
 
-import "fmt"
+import (
+	"fmt"
+	"strings"
+)
 
 // ResumeCommand returns the CLI command to resume a session for the given agent.
 // Returns empty string for unknown agents or empty session IDs.
@@ -23,16 +26,23 @@ func ResumeCommand(agent, sessionID string) string {
 		return fmt.Sprintf("kilo --session=%s", sessionID)
 	case "cursor":
 		return fmt.Sprintf("cursor-agent --resume=%q", sessionID)
+	case "grok":
+		return fmt.Sprintf("grok --resume %s", shellQuoteArg(sessionID))
 	case "kimi":
 		return fmt.Sprintf("kimi --resume %s", sessionID)
 	default:
 		return ""
 	}
 }
 
+// shellQuoteArg returns one POSIX shell word using single-quote escaping.
+func shellQuoteArg(value string) string {
+	return "'" + strings.ReplaceAll(value, "'", "'\\''") + "'"
+}
+
 // ResumeArgv returns the executable argv to resume a session, or nil when
-// the agent has no resume command lazyagent is willing to exec (grok has
-// none; opencode/kilo/cursor have a display string only — see ResumeCommand).
+// the agent has no resume command lazyagent is willing to exec.
+// OpenCode, Kilo, and Cursor have a display string only; see ResumeCommand.
 // "Openable" everywhere in the codebase means ResumeArgv != nil.
 func ResumeArgv(agent, sessionID string) []string {
 	if sessionID == "" {
@@ -47,6 +57,8 @@ func ResumeArgv(agent, sessionID string) []string {
 		return []string{"amp", "threads", "continue", sessionID}
 	case "pi":
 		return []string{"pi", "--session", sessionID}
+	case "grok":
+		return []string{"grok", "--resume", sessionID}
 	case "kimi":
 		return []string{"kimi", "--resume", sessionID}
 	default:

internal/core/resume_test.go

@@ -16,6 +16,9 @@ func TestResumeCommand(t *testing.T) {
 		{"opencode", "abc-123", "opencode -s abc-123"},
 		{"kilo", "abc-123", "kilo --session=abc-123"},
 		{"cursor", "abc-123", `cursor-agent --resume="abc-123"`},
+		{"grok", "abc-123", "grok --resume 'abc-123'"},
+		{"grok", "abc $(touch /tmp/pwn) 'quoted'", `grok --resume 'abc $(touch /tmp/pwn) '\''quoted'\'''`},
+		{"kimi", "abc-123", "kimi --resume abc-123"},
 		{"unknown", "abc-123", ""},
 		{"claude", "", ""},
 		{"", "abc-123", ""},
@@ -37,12 +40,12 @@ func TestResumeArgv(t *testing.T) {
 		{"codex", []string{"codex", "resume", "abc"}},
 		{"amp", []string{"amp", "threads", "continue", "abc"}},
 		{"pi", []string{"pi", "--session", "abc"}},
+		{"grok", []string{"grok", "--resume", "abc"}},
 		{"kimi", []string{"kimi", "--resume", "abc"}},
 		// Display-only agents: copyable via ResumeCommand but not executable.
 		{"opencode", nil},
 		{"kilo", nil},
 		{"cursor", nil},
-		{"grok", nil},
 		{"unknown", nil},
 	}
 	for _, c := range cases {

internal/search/query_test.go

@@ -78,19 +78,28 @@ func TestNormalizeArgsAllowsFlagsAfterQuery(t *testing.T) {
 }
 
 func TestResumeCommand(t *testing.T) {
-	cmd, display := resumeCommand("codex", "abc123")
-	if cmd == nil {
-		t.Fatal("resumeCommand returned nil")
+	tests := []struct {
+		agent, executable, wantArgs, wantDisplay string
+	}{
+		{"codex", "codex", "codex resume abc123", "codex resume abc123"},
+		{"grok", "grok", "grok --resume abc123", "grok --resume 'abc123'"},
 	}
-	if filepath.Base(cmd.Path) != "codex" {
-		t.Fatalf("cmd.Path = %q, want codex executable", cmd.Path)
-	}
-	got := strings.Join(cmd.Args, " ")
-	want := "codex resume abc123"
-	if got != want {
-		t.Fatalf("args = %q, want %q", got, want)
-	}
-	if display != want {
-		t.Fatalf("display = %q, want %q", display, want)
+	for _, tt := range tests {
+		t.Run(tt.agent, func(t *testing.T) {
+			cmd, display := resumeCommand(tt.agent, "abc123")
+			if cmd == nil {
+				t.Fatal("resumeCommand returned nil")
+			}
+			if filepath.Base(cmd.Path) != tt.executable {
+				t.Fatalf("cmd.Path = %q, want %s executable", cmd.Path, tt.executable)
+			}
+			got := strings.Join(cmd.Args, " ")
+			if got != tt.wantArgs {
+				t.Fatalf("args = %q, want %q", got, tt.wantArgs)
+			}
+			if display != tt.wantDisplay {
+				t.Fatalf("display = %q, want %q", display, tt.wantDisplay)
+			}
+		})
 	}
 }

internal/sessions/json_test.go

@@ -77,13 +77,13 @@ func TestWriteJSONAllFieldsPresentEvenWhenEmpty(t *testing.T) {
 			_ = v
 		}
 	}
-	// grok has no resume command and neither session has a name: both must
-	// be present as empty strings, not omitted.
+	// Neither session has a name, so both names must be present as empty
+	// strings rather than omitted.
 	if out[0]["name"] != "" {
 		t.Errorf("grok row name = %v, want empty string", out[0]["name"])
 	}
-	if out[0]["resume_command"] != "" {
-		t.Errorf("grok row resume_command = %v, want empty string", out[0]["resume_command"])
+	if out[0]["resume_command"] != "grok --resume 'g1'" {
+		t.Errorf("grok row resume_command = %v, want grok --resume 'g1'", out[0]["resume_command"])
 	}
 	if out[1]["name"] != "" {
 		t.Errorf("claude row name = %v, want empty string", out[1]["name"])