feat(runner): manual summarization mode in the run loop

RunOnce now reads the user's mode (GetAutoSummarize) at the start of each pass:
- Auto (unchanged): summarize every unseen video.
- Manual: still UpsertVideo for every candidate (discovery — the user sees new
  videos in the list), but skip ProcessNewVideo unless the video is queued
  (RequestedVideoIDs). A queued video is summarized, then its flag is cleared
  (ClearSummarizeRequested) so it is not re-processed and the UI drops "Queued".

New Stats.SkippedManual counts discovered-but-unqueued videos. The VideoStore
port gains the three methods; the existing auto-mode tests set auto:true.

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

internal/runner/runner.go

@@ -23,10 +23,15 @@ import (
 )
 
 // VideoStore is the durable persistence the run loop needs: assign a stable id +
-// metadata, and read the already-summarized set. *store.Store satisfies it.
+// metadata, read the already-summarized set, and (for manual summarization mode)
+// read the user's mode + queued videos and clear a video's queue flag once it has
+// been summarized. *store.Store satisfies it.
 type VideoStore interface {
 	UpsertVideo(ctx context.Context, v domain.Video) (string, error)
 	SeenVideoIDs(ctx context.Context, userID string) (map[string]bool, error)
+	GetAutoSummarize(ctx context.Context, userID string) (bool, error)
+	RequestedVideoIDs(ctx context.Context, userID string) (map[string]bool, error)
+	ClearSummarizeRequested(ctx context.Context, userID, videoID string) error
 }
 
 // Processor runs the core use case for a single video. *usecase.Engine
@@ -59,6 +64,7 @@ type Stats struct {
 	Summarized    int
 	SkippedSeen   int
 	SkippedNoText int
+	SkippedManual int // discovered but not queued, in manual mode
 	Errors        int
 }
 
@@ -82,6 +88,22 @@ func (r *Runner) RunOnce(ctx context.Context) (Stats, error) {
 		return stats, fmt.Errorf("runner: load seen videos: %w", err)
 	}
 
+	// Summarization mode (per-user, ADR-012). Auto = summarize every unseen video
+	// (the original behavior). Manual = still discover/persist videos so the user
+	// sees them, but only summarize the ones explicitly queued via the web UI
+	// (summarize_requested). The queued set is loaded once per pass, like seen.
+	auto, err := r.store.GetAutoSummarize(ctx, r.userID)
+	if err != nil {
+		return stats, fmt.Errorf("runner: load summarize mode: %w", err)
+	}
+	var requested map[string]bool
+	if !auto {
+		requested, err = r.store.RequestedVideoIDs(ctx, r.userID)
+		if err != nil {
+			return stats, fmt.Errorf("runner: load requested videos: %w", err)
+		}
+	}
+
 	subs, err := r.src.ListSubscriptions(ctx, r.userID)
 	if err != nil {
 		return stats, fmt.Errorf("runner: list subscriptions: %w", err)
@@ -112,6 +134,14 @@ func (r *Runner) RunOnce(ctx context.Context) (Stats, error) {
 			}
 			seen[id] = true // also guard against the same video within this pass
 
+			// Manual mode: skip summarization for videos the user has not queued.
+			// Discovery already happened (UpsertVideo above), so the new video is
+			// visible in the list; it just isn't summarized until requested.
+			if !auto && !requested[id] {
+				stats.SkippedManual++
+				continue
+			}
+
 			if fetchDelay > 0 {
 				time.Sleep(fetchDelay)
 			}
@@ -127,6 +157,15 @@ func (r *Runner) RunOnce(ctx context.Context) (Stats, error) {
 				r.log.Info("skipped video (no transcript)", "video", v.ProviderVideoID, "title", v.Title)
 			case res.Summary != nil:
 				stats.Summarized++
+				// In manual mode the video was processed because it was queued;
+				// clear the flag so it is not re-summarized and the UI drops the
+				// "Queued" chip. (Auto mode never sets the flag.)
+				if !auto {
+					if err := r.store.ClearSummarizeRequested(ctx, r.userID, id); err != nil {
+						errs = append(errs, fmt.Errorf("clear summarize flag %q: %w", v.ProviderVideoID, err))
+						stats.Errors++
+					}
+				}
 				r.log.Info("summarized video", "video", v.ProviderVideoID, "title", v.Title,
 					"provider", res.Summary.AIProvider, "model", res.Summary.AIModel)
 			}
@@ -145,7 +184,7 @@ func (r *Runner) Loop(ctx context.Context, interval time.Duration) error {
 		r.log.Info("run pass complete",
 			"candidates", stats.Candidates, "summarized", stats.Summarized,
 			"skipped_seen", stats.SkippedSeen, "skipped_no_text", stats.SkippedNoText,
-			"errors", stats.Errors)
+			"skipped_manual", stats.SkippedManual, "errors", stats.Errors)
 		if err != nil {
 			r.log.Warn("run pass had errors", "err", err)
 		}