feat: /bg inject — merge background task results into main session

Add /bg inject <id> command that takes a completed background task's
result and injects it into the current main session as a /btw context
note. This enables a unique workflow: run analysis in background,
then selectively bring results into the active conversation.

- BackgroundTask.ResultText field stores raw Claude response
- GetResult() returns result text and project for completed tasks
- /bg inject queues result as btw message (truncated to 4000 runes)
- Help text updated in both /help and /bg

This "independent session analysis → selective context merge" pattern
is unique to Pocket Claude — no other AI tool offers this workflow.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: GrapeInTheTree

internal/bot/commands.go

@@ -68,6 +68,7 @@ func (b *Bot) cmdHelp() {
 		"/bg `<message>` — Run task in background\n" +
 		"/bg `<project>` `<message>` — In specific project\n" +
 		"/bg status — Check running tasks\n" +
+		"/bg inject `<id>` — Inject result into session\n" +
 		"/bg cancel `<id>` — Cancel a task\n\n" +
 		"*Queue:*\n" +
 		"/status — Message queue status\n" +
@@ -504,9 +505,10 @@ func (b *Bot) cmdBg(msg *tgbotapi.Message) {
 				"`/bg <message>` — Run in current project\n" +
 				"`/bg <project> <message>` — Run in specific project\n" +
 				"`/bg status` — Show running tasks\n" +
+				"`/bg inject <id>` — Inject result into session\n" +
 				"`/bg cancel <id>` — Cancel a task\n\n" +
-				"Background tasks run independently,\n" +
-				"so you can keep chatting.")
+				"Background tasks run independently.\n" +
+				"Use inject to bring results into your conversation.")
 		return
 	}
 
@@ -516,6 +518,39 @@ func (b *Bot) cmdBg(msg *tgbotapi.Message) {
 		return
 	}
 
+	// /bg inject <id>
+	if strings.HasPrefix(args, "inject ") {
+		taskID := strings.TrimSpace(strings.TrimPrefix(args, "inject"))
+		if taskID == "" {
+			b.sendMessage("Usage: /bg inject <task_id>")
+			return
+		}
+		resultText, projectName, err := b.worker.GetBackgroundResult(taskID)
+		if err != nil {
+			b.sendMessage("Failed: " + err.Error())
+			return
+		}
+
+		// Truncate to avoid excessive context injection
+		injected := worker.Truncate(resultText, 4000)
+		btwText := fmt.Sprintf("[Background task %s result from project %q] %s", taskID, projectName, injected)
+
+		inboxMsg := store.InboxMessage{
+			ID:        fmt.Sprintf("msg_%d", time.Now().UnixMilli()),
+			Text:      "[BTW context note, just acknowledge briefly] " + btwText,
+			Status:    store.StatusPending,
+			Timestamp: time.Now().UTC().Format(time.RFC3339),
+			Project:   b.worker.ActiveProject(),
+		}
+		if err := b.store.AppendToInbox(inboxMsg); err != nil {
+			b.sendMessage("Failed to inject: " + err.Error())
+			return
+		}
+		b.worker.Enqueue(inboxMsg)
+		b.sendMessage(fmt.Sprintf("💉 Injected %s into current session.\nClaude will now have context from that background task.", taskID))
+		return
+	}
+
 	// /bg cancel <id>
 	if strings.HasPrefix(args, "cancel ") {
 		taskID := strings.TrimSpace(strings.TrimPrefix(args, "cancel"))

internal/worker/background.go

@@ -26,13 +26,14 @@ func init() {
 
 // BackgroundTask represents a single background task.
 type BackgroundTask struct {
-	ID        string
-	Project   string
-	Message   string
-	State     string // "running", "approval", "done", "failed", "cancelled"
-	StartedAt time.Time
-	Cancel    context.CancelFunc
-	Error     string
+	ID         string
+	Project    string
+	Message    string
+	State      string // "running", "approval", "done", "failed", "cancelled"
+	StartedAt  time.Time
+	Cancel     context.CancelFunc
+	Error      string
+	ResultText string // raw Claude response, stored for /bg inject
 }
 
 // BackgroundPool manages concurrent background tasks with independent executors.
@@ -232,6 +233,11 @@ func (bp *BackgroundPool) ResolveApproval(id string, approved bool) {
 }
 
 func (bp *BackgroundPool) sendResult(task *BackgroundTask, result *store.CLIResult) {
+	// Store raw result for /bg inject
+	bp.mu.Lock()
+	task.ResultText = result.Result
+	bp.mu.Unlock()
+
 	elapsed := time.Since(task.StartedAt)
 	var elapsedStr string
 	if elapsed < time.Minute {
@@ -263,6 +269,24 @@ func (bp *BackgroundPool) sendResult(task *BackgroundTask, result *store.CLIResu
 	bp.logger.Info("Background task completed", "id", task.ID, "elapsed", elapsedStr)
 }
 
+// GetResult returns the result text and project for a completed background task.
+func (bp *BackgroundPool) GetResult(taskID string) (resultText, projectName string, err error) {
+	bp.mu.Lock()
+	defer bp.mu.Unlock()
+
+	t, ok := bp.tasks[taskID]
+	if !ok {
+		return "", "", fmt.Errorf("task %q not found", taskID)
+	}
+	if t.State == "running" || t.State == "approval" {
+		return "", "", fmt.Errorf("task %q is still running", taskID)
+	}
+	if t.ResultText == "" {
+		return "", "", fmt.Errorf("task %q has no result", taskID)
+	}
+	return t.ResultText, t.Project, nil
+}
+
 func (bp *BackgroundPool) setTaskState(id, state, errMsg string) {
 	bp.mu.Lock()
 	defer bp.mu.Unlock()

internal/worker/background_test.go

@@ -266,6 +266,55 @@ func TestTaskCounterUniqueness(t *testing.T) {
 	}
 }
 
+func TestBackgroundPoolGetResult(t *testing.T) {
+	pool := NewBackgroundPool(nil, nil, nil, nil, testLogger())
+
+	pool.mu.Lock()
+	pool.tasks["bg_done"] = &BackgroundTask{
+		ID: "bg_done", State: "done", Project: "my-app",
+		ResultText: "Found 3 security issues", StartedAt: time.Now(),
+	}
+	pool.tasks["bg_running"] = &BackgroundTask{
+		ID: "bg_running", State: "running", Project: "api",
+		StartedAt: time.Now(),
+	}
+	pool.tasks["bg_empty"] = &BackgroundTask{
+		ID: "bg_empty", State: "done", Project: "api",
+		ResultText: "", StartedAt: time.Now(),
+	}
+	pool.mu.Unlock()
+
+	// Success case
+	text, proj, err := pool.GetResult("bg_done")
+	if err != nil {
+		t.Fatalf("GetResult bg_done: %v", err)
+	}
+	if text != "Found 3 security issues" {
+		t.Errorf("text = %q, want 'Found 3 security issues'", text)
+	}
+	if proj != "my-app" {
+		t.Errorf("project = %q, want 'my-app'", proj)
+	}
+
+	// Still running
+	_, _, err = pool.GetResult("bg_running")
+	if err == nil || !strings.Contains(err.Error(), "still running") {
+		t.Errorf("Expected 'still running' error, got %v", err)
+	}
+
+	// Empty result
+	_, _, err = pool.GetResult("bg_empty")
+	if err == nil || !strings.Contains(err.Error(), "no result") {
+		t.Errorf("Expected 'no result' error, got %v", err)
+	}
+
+	// Not found
+	_, _, err = pool.GetResult("bg_nonexistent")
+	if err == nil || !strings.Contains(err.Error(), "not found") {
+		t.Errorf("Expected 'not found' error, got %v", err)
+	}
+}
+
 func TestTaskCounterConcurrency(t *testing.T) {
 	seen := sync.Map{}
 	var wg sync.WaitGroup

internal/worker/worker.go

@@ -405,6 +405,11 @@ func (w *Worker) CancelBackground(taskID string) error {
 	return w.bgPool.Cancel(taskID)
 }
 
+// GetBackgroundResult returns the result text and project for a completed bg task.
+func (w *Worker) GetBackgroundResult(taskID string) (string, string, error) {
+	return w.bgPool.GetResult(taskID)
+}
+
 // ResolveBackgroundApproval resolves a pending background task approval.
 func (w *Worker) ResolveBackgroundApproval(id string, approved bool) {
 	w.bgPool.ResolveApproval(id, approved)