diff --git a/CLAUDE.md b/CLAUDE.md
index 4a2feab..a673dc2 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -45,7 +45,7 @@ go run ./cmd/gws    # or go run .
 
 ## Current Version
 
-**v1.9.0** - Gmail pagination & slides documentation. Adds `--all` flag to `gmail list` for fetching >500 results via pagination. Enhanced slides SKILL.md with styling tips and workflow examples.
+**v1.10.0** - Gmail label support & morning skill optimization. Adds `--include-labels` flag to `gmail list` for surfacing label IDs. Morning scripts use labels from inbox data instead of extra API calls (~2-3s savings).
 
 ## Roadmap
 
diff --git a/Makefile b/Makefile
index fe5a6a3..399caed 100644
--- a/Makefile
+++ b/Makefile
@@ -3,7 +3,7 @@ PKG := ./cmd/gws
 BUILD_DIR := ./bin
 
 # Version info
-VERSION ?= 1.9.0
+VERSION ?= 1.10.0
 COMMIT := $(shell git rev-parse --short HEAD 2>/dev/null || echo "unknown")
 BUILD_DATE := $(shell date -u +"%Y-%m-%dT%H:%M:%SZ")
 LDFLAGS := -ldflags "-X github.com/omriariav/workspace-cli/cmd.Version=$(VERSION) \
diff --git a/README.md b/README.md
index d9bbb17..f769620 100644
--- a/README.md
+++ b/README.md
@@ -94,7 +94,7 @@ Add `--format text` to any command for human-readable output.
 
 | Command | Description |
 |---------|-------------|
-| `gws gmail list` | List threads with `thread_id` and `message_id` (`--max`, `--query`, `--all` for pagination) |
+| `gws gmail list` | List threads with `thread_id` and `message_id` (`--max`, `--query`, `--all`, `--include-labels`) |
 | `gws gmail read <id>` | Read message body and headers |
 | `gws gmail thread <id>` | Read full thread conversation |
 | `gws gmail send` | Send email (`--to`, `--subject`, `--body`, `--cc`, `--bcc`, `--thread-id`, `--reply-to-message-id`) |
diff --git a/cmd/gmail.go b/cmd/gmail.go
index 4eb7703..f06d1de 100644
--- a/cmd/gmail.go
+++ b/cmd/gmail.go
@@ -7,6 +7,7 @@ import (
 	"net/url"
 	"os"
 	"regexp"
+	"sort"
 	"strings"
 
 	"github.com/omriariav/workspace-cli/internal/client"
@@ -162,6 +163,7 @@ func init() {
 	gmailListCmd.Flags().Int64("max", 10, "Maximum number of results (use --all for unlimited)")
 	gmailListCmd.Flags().String("query", "", "Gmail search query (e.g., 'is:unread', 'from:someone@example.com')")
 	gmailListCmd.Flags().Bool("all", false, "Fetch all matching results (may take time for large result sets)")
+	gmailListCmd.Flags().Bool("include-labels", false, "Include Gmail label IDs in output")
 
 	// Send flags
 	gmailSendCmd.Flags().String("to", "", "Recipient email address (required)")
@@ -204,6 +206,7 @@ func runGmailList(cmd *cobra.Command, args []string) error {
 	maxResults, _ := cmd.Flags().GetInt64("max")
 	query, _ := cmd.Flags().GetString("query")
 	fetchAll, _ := cmd.Flags().GetBool("all")
+	includeLabels, _ := cmd.Flags().GetBool("include-labels")
 
 	// Gmail API has a hard limit of 500 results per request
 	const apiMaxPerPage int64 = 500
@@ -296,6 +299,21 @@ func runGmailList(cmd *cobra.Command, args []string) error {
 					threadInfo["date"] = header.Value
 				}
 			}
+
+			if includeLabels {
+				labelSet := make(map[string]bool)
+				for _, m := range threadDetail.Messages {
+					for _, lbl := range m.LabelIds {
+						labelSet[lbl] = true
+					}
+				}
+				labels := make([]string, 0, len(labelSet))
+				for lbl := range labelSet {
+					labels = append(labels, lbl)
+				}
+				sort.Strings(labels)
+				threadInfo["labels"] = labels
+			}
 		}
 
 		results = append(results, threadInfo)
diff --git a/cmd/gmail_test.go b/cmd/gmail_test.go
index 4744975..bb49e90 100644
--- a/cmd/gmail_test.go
+++ b/cmd/gmail_test.go
@@ -1414,3 +1414,131 @@ func TestGmailList_MaxRespected_MockServer(t *testing.T) {
 		t.Errorf("expected 3 threads, got %d", len(resp.Threads))
 	}
 }
+
+// TestGmailListCommand_IncludeLabelsFlag tests that the --include-labels flag exists
+func TestGmailListCommand_IncludeLabelsFlag(t *testing.T) {
+	cmd := gmailListCmd
+
+	flag := cmd.Flags().Lookup("include-labels")
+	if flag == nil {
+		t.Error("expected --include-labels flag to exist")
+	}
+	if flag.DefValue != "false" {
+		t.Errorf("expected --include-labels default 'false', got '%s'", flag.DefValue)
+	}
+}
+
+// TestGmailList_IncludeLabels_MockServer tests that --include-labels returns union of all message labels
+func TestGmailList_IncludeLabels_MockServer(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+
+		// Threads list
+		if r.URL.Path == "/gmail/v1/users/me/threads" && r.Method == "GET" {
+			resp := map[string]interface{}{
+				"threads": []map[string]interface{}{
+					{"id": "thread-lbl", "snippet": "Test labels"},
+				},
+			}
+			json.NewEncoder(w).Encode(resp)
+			return
+		}
+
+		// Thread get with metadata — two messages with different labels
+		if r.URL.Path == "/gmail/v1/users/me/threads/thread-lbl" && r.Method == "GET" {
+			resp := map[string]interface{}{
+				"id": "thread-lbl",
+				"messages": []map[string]interface{}{
+					{
+						"id":       "msg-001",
+						"threadId": "thread-lbl",
+						"labelIds": []string{"INBOX", "UNREAD", "CATEGORY_PROMOTIONS"},
+						"payload": map[string]interface{}{
+							"headers": []map[string]string{
+								{"name": "Subject", "value": "Promo email"},
+								{"name": "From", "value": "promo@example.com"},
+								{"name": "Date", "value": "Mon, 6 Feb 2026 10:00:00 +0000"},
+							},
+						},
+					},
+					{
+						"id":       "msg-002",
+						"threadId": "thread-lbl",
+						"labelIds": []string{"INBOX", "STARRED"},
+						"payload": map[string]interface{}{
+							"headers": []map[string]string{
+								{"name": "Subject", "value": "Re: Promo email"},
+								{"name": "From", "value": "reply@example.com"},
+								{"name": "Date", "value": "Mon, 6 Feb 2026 11:00:00 +0000"},
+							},
+						},
+					},
+				},
+			}
+			json.NewEncoder(w).Encode(resp)
+			return
+		}
+
+		t.Logf("Unexpected request: %s %s", r.Method, r.URL.Path)
+		w.WriteHeader(http.StatusNotFound)
+	}))
+	defer server.Close()
+
+	svc, err := gmail.NewService(context.Background(), option.WithoutAuthentication(), option.WithEndpoint(server.URL))
+	if err != nil {
+		t.Fatalf("failed to create gmail service: %v", err)
+	}
+
+	// Fetch thread list
+	listResp, err := svc.Users.Threads.List("me").MaxResults(10).Do()
+	if err != nil {
+		t.Fatalf("failed to list threads: %v", err)
+	}
+
+	if len(listResp.Threads) != 1 {
+		t.Fatalf("expected 1 thread, got %d", len(listResp.Threads))
+	}
+
+	// Get thread detail (same as runGmailList does)
+	threadDetail, err := svc.Users.Threads.Get("me", listResp.Threads[0].Id).Format("metadata").MetadataHeaders("Subject", "From", "Date").Do()
+	if err != nil {
+		t.Fatalf("failed to get thread detail: %v", err)
+	}
+
+	// Simulate includeLabels=true logic
+	labelSet := make(map[string]bool)
+	for _, m := range threadDetail.Messages {
+		for _, lbl := range m.LabelIds {
+			labelSet[lbl] = true
+		}
+	}
+	labels := make([]string, 0, len(labelSet))
+	for lbl := range labelSet {
+		labels = append(labels, lbl)
+	}
+
+	// Verify union of labels from both messages
+	expected := map[string]bool{
+		"INBOX":                true,
+		"UNREAD":               true,
+		"CATEGORY_PROMOTIONS":  true,
+		"STARRED":              true,
+	}
+	if len(labels) != len(expected) {
+		t.Errorf("expected %d labels, got %d: %v", len(expected), len(labels), labels)
+	}
+	for _, lbl := range labels {
+		if !expected[lbl] {
+			t.Errorf("unexpected label: %s", lbl)
+		}
+	}
+
+	// Simulate includeLabels=false — labels should NOT be in output
+	threadInfo := map[string]interface{}{
+		"thread_id": "thread-lbl",
+	}
+	// Without the flag, no "labels" key should be set
+	if _, exists := threadInfo["labels"]; exists {
+		t.Error("labels should not be present when include-labels is false")
+	}
+}
diff --git a/skills/morning/SKILL.md b/skills/morning/SKILL.md
index 605c198..a3c71e6 100644
--- a/skills/morning/SKILL.md
+++ b/skills/morning/SKILL.md
@@ -1,6 +1,6 @@
 ---
 name: gws-morning
-version: 0.5.0
+version: 0.6.0
 description: "AI-powered morning inbox briefing. Reads Gmail, Google Tasks, Calendar, and OKR sheets to produce a prioritized daily briefing with actionable recommendations. Triggers: /morning, morning briefing, inbox triage, email priorities, daily digest."
 metadata:
   short-description: AI inbox briefing with OKR/task matching
@@ -55,6 +55,16 @@ The config contains:
 - `inbox_query` — Gmail search query (default: `"is:unread in:inbox"`)
 - `daily_log_doc_id` — Google Doc ID for the daily log (empty = skip logging)
 
+### Cache label list
+
+Fetch the Gmail label list once at session start to avoid re-fetching on every label operation:
+
+```bash
+gws gmail labels > "$SCRATCHPAD_DIR/morning/labels.json"
+```
+
+This cached list is passed to the label-resolver sub-agent when the user picks "Label & archive" during triage. Saves ~4k tokens + 2-3s per label operation vs fetching each time.
+
 ## Step 2: Launch Background Data Gathering
 
 Launch a **background agent** to run prefetch + pre-filter while the main agent shows the user immediate context.
@@ -118,7 +128,7 @@ Starting triage.
 ### What the scripts do internally
 
 **Prefetch** (`morning-prefetch.sh`):
-- `gws gmail list --max <max_unread> --query "is:unread in:inbox"` — **MUST use `in:inbox`**
+- `gws gmail list --max <max_unread> --query "is:unread in:inbox" --include-labels` — **MUST use `in:inbox`**
 - `gws calendar events --days 2` — today + tomorrow
 - `gws tasks lists` → `gws tasks list <id>` for each list
 - `gws sheets read <okr_sheet_id> "<sheet_name>!A1:Q100"` — OKR data (cached 24h)
@@ -129,9 +139,25 @@ Starting triage.
 - Archives calendar invite emails (Invitation:, Updated Invitation:, Canceled: from calendar-notification@google.com)
 - Writes `prefiltered.json` (remaining) and `auto_handled.json` (archived with reasons)
 
+### Enrich emails (deterministic tags)
+
+After pre-filtering, run enrichment to add deterministic tags:
+
+```bash
+scripts/morning-enrich.sh "$SCRATCHPAD_DIR/morning" ~/.config/gws/inbox-skill.yaml
+```
+
+This reads `prefiltered.json` + `calendar.json` + config, and writes `enriched.json` with tags:
+- `noise_signal`: "promotions" if CATEGORY_PROMOTIONS label
+- `vip_sender`: true if sender matches VIP list
+- `starred`: true if STARRED label
+- `is_thread`: true if multi-message thread
+- `calendar_match`: matching meeting title
+
 ### Output files
 
-- `prefiltered.json` — remaining emails for AI classification (OOO/invites removed)
+- `prefiltered.json` — remaining emails after OOO/invite removal
+- `enriched.json` — emails with deterministic tags for AI classification
 - `auto_handled.json` — items archived by pre-filter with reasons
 - `classified.json` — classification results from background agent
 - `inbox.json` — original unread inbox emails
@@ -141,20 +167,18 @@ Starting triage.
 
 ## Step 3: Classify (Background Agent)
 
-The background agent classifies all remaining emails using the rules from `skills/morning/prompts/triage-agent.md`. This happens as part of the background agent launched in Step 2 — the main agent does NOT classify.
+The background agent classifies enriched emails using the rules from `skills/morning/prompts/triage-agent.md`. This happens as part of the background agent launched in Step 2 — the main agent does NOT classify.
 
-For each email, the background agent determines:
-- **Classification:** ACT_NOW / REVIEW / NOISE
-- **Priority score:** 1-5 (highest signal, not additive)
-- **Summary:** 1-2 lines
-- **Matches:** OKR, task, or calendar match if any
-- **Recommended action**
+The background agent returns a grouped JSON result (lean format — see `triage-agent.md`):
+- **`auto_handled`:** NOISE items — thread IDs + reason only (no subject/sender/matches)
+- **`needs_input`:** ACT_NOW and REVIEW items with priority, summary, sender, subject, non-null matches, and `suggested_label`
+- **`batch_stats`:** Total counts per category
 
-The background agent writes results to `classified.json` and archives all NOISE items via `gws gmail archive-thread <thread_id> --quiet`.
+The main agent uses `auto_handled` thread IDs for bulk archive via `scripts/bulk-gmail.sh archive-thread`, and `needs_input` for guided triage.
 
 ## Step 4: Collect Results
 
-When the background agent completes, the main agent reads `classified.json` and presents the auto-action summary.
+When the background agent completes, the main agent bulk-archives NOISE items and presents the auto-action summary.
 
 ### Classification Categories
 
@@ -282,7 +306,7 @@ Use AskUserQuestion with **4 options**. Pick the best 4 from the pool based on c
 
 **Standard options (always include):**
 - **Mark as read** — Mark read, keep in inbox: `gws gmail label <message_id> --remove UNREAD --quiet`
-- **Archive** — Remove from inbox: `gws gmail archive-thread <thread_id> --quiet`
+- **Archive** — If `suggested_label` exists, apply label first then archive: `gws gmail label <message_id> --add "<suggested_label>" --quiet` followed by `gws gmail archive-thread <thread_id> --quiet`. Show: "Archived with label: <label>". If no suggested label, just archive. User can override with "Other" to specify a different label.
 - **Skip** — Move to next item (keeps email **unread**)
 
 **Rotate the 4th slot based on context:**
@@ -290,7 +314,7 @@ Use AskUserQuestion with **4 options**. Pick the best 4 from the pool based on c
 - **Reply** — Compose a reply: fetch email via `gws gmail read <message_id>`, draft a response using conversation context (OKR/task matches, deep-dive insights if available), present draft for user approval, then `gws gmail reply <message_id> --body "<reply>"`. Thread ID, subject, and headers are auto-populated.
 - **Reply All** — Same as Reply but to all recipients: `gws gmail reply <message_id> --body "<reply>" --all`
 - **Forward** — Forward to a colleague: ask who, fetch email content (`read` for single message, `thread` for conversations), compose brief forwarding context (why forwarding + 1-2 key points, include OKR/task match if relevant), then `gws gmail send --to "<email>" --subject "Fwd: <subject>" --body "<your note>\n\n---\nOriginal message:\n<content>"`
-- **Label & archive** — Spawn label-resolver sub-agent (`skills/morning/prompts/label-resolver.md`) with `action=archive`
+- **Label & archive** — Spawn label-resolver sub-agent (`skills/morning/prompts/label-resolver.md`) with `action=archive` and `labels_file="$SCRATCHPAD_DIR/morning/labels.json"` (cached from Step 1)
 - **Add task & archive** — Ask for title, run `gws tasks create`, then archive
 - **Open in browser** — Run `open "https://mail.google.com/mail/u/0/#inbox/<thread_id>"`
 
@@ -329,10 +353,9 @@ skills/morning/scripts/bulk-gmail.sh mark-read <id1> <id2> ...
 Spawn a sub-agent to fetch, summarize, and cross-reference the email.
 
 **Prompt file:** `skills/morning/prompts/deep-dive.md`
-**Model:** `sonnet` — **always use sonnet** (haiku is unreliable for email reading)
-**Agent type:** `general-purpose`
+**Model/agent_type:** defined in prompt frontmatter (`sonnet` / `general-purpose`)
 
-Pass: email ID, message count (for `read` vs `thread`), OKR/task/calendar context.
+Pass: **user context** (name, email, company, role/team), email ID, message count (for `read` vs `thread`), OKR/task/calendar context.
 
 The sub-agent returns a structured brief. Present it and ask what to do next:
 - **Open comment/doc** — open direct link (if available)
@@ -615,5 +638,6 @@ Common `gws` commands used during triage:
 
 ### Label Operations
 - Gmail labels are resolved by **display name** (case-insensitive), not by internal ID.
-- For label operations during triage, use the **label-resolver sub-agent** (`skills/morning/prompts/label-resolver.md`) to avoid loading the full label list (4000+ labels) into the main context.
+- **Labels are cached at session start** (Step 1) in `$SCRATCHPAD_DIR/morning/labels.json`. Pass `labels_file` to the label-resolver sub-agent to avoid re-fetching on every label operation (~4k tokens + 2-3s saved per operation).
+- For label operations during triage, use the **label-resolver sub-agent** (`skills/morning/prompts/label-resolver.md`) — keeps the full label list (4000+ labels) out of the main context.
 - Common label patterns: `gws gmail label <id> --add "STARRED"`, `gws gmail label <id> --remove "UNREAD"`
diff --git a/skills/morning/compact-prompt.md b/skills/morning/compact-prompt.md
index 1aade8b..f148141 100644
--- a/skills/morning/compact-prompt.md
+++ b/skills/morning/compact-prompt.md
@@ -1,9 +1,13 @@
+---
+name: compact-prompt
+type: template
+description: Session resumption template for /morning triage. Not a sub-agent.
+---
+
 # /morning Compact Prompt
 
 Use this when context runs out during a `/morning` triage session. Copy the template below, fill in the state from the conversation, and paste it to resume.
 
----
-
 ## Template
 
 ```
diff --git a/skills/morning/prompts/deep-dive.md b/skills/morning/prompts/deep-dive.md
index 1954bb1..012ab48 100644
--- a/skills/morning/prompts/deep-dive.md
+++ b/skills/morning/prompts/deep-dive.md
@@ -1,16 +1,27 @@
-# Deep-Dive Email Summarizer Prompt
-
-**Model:** `sonnet` — always use sonnet. Haiku is unreliable for email reading (fails to fetch content in practice).
+---
+name: deep-dive
+model: sonnet
+agent_type: general-purpose
+description: Fetch and analyze a single email/thread with cross-references and suggested actions
+notes: Always use sonnet - haiku is unreliable for email reading (fails to fetch content in practice)
+---
 
-**Agent type:** `general-purpose`
+# Deep-Dive Email Summarizer Prompt
 
-**Purpose:** When the user picks "Dig Deeper" on a specific email, fetch the full email/thread and return a structured brief with cross-references and suggested actions.
+When the user picks "Dig Deeper" on a specific email, fetch the full email/thread and return a structured brief with cross-references and suggested actions.
 
 ## Prompt Template
 
 ```
 You are a deep-dive email summarizer for an inbox triage skill. Fetch the email and return a structured brief.
 
+## User Context
+
+You will receive the user's name, email, company, and role/team. Use this to:
+- Determine the user's relationship to the email (sender, recipient, CC'd, mentioned)
+- Assess whether the user owns the next action
+- Understand company-specific context (internal vs external communication)
+
 ## Task
 
 Fetch this email:
diff --git a/skills/morning/prompts/label-resolver.md b/skills/morning/prompts/label-resolver.md
index 93476de..847cfd7 100644
--- a/skills/morning/prompts/label-resolver.md
+++ b/skills/morning/prompts/label-resolver.md
@@ -1,10 +1,13 @@
-# Label Resolver Prompt
-
-**Model:** `haiku` — simple lookup task, no complex reasoning needed.
+---
+name: label-resolver
+model: haiku
+agent_type: general-purpose
+description: Fuzzy-match and apply Gmail labels during triage using cached label list
+---
 
-**Agent type:** `general-purpose`
+# Label Resolver Prompt
 
-**Purpose:** Apply Gmail labels during triage without loading the full label list (4000+ labels) into the main conversation context. Handles fuzzy label matching, archiving, and marking as read.
+Apply Gmail labels during triage without loading the full label list (4000+ labels) into the main conversation context. Handles fuzzy label matching, archiving, and marking as read.
 
 ## Prompt Template
 
@@ -17,15 +20,19 @@ You are a Gmail label resolver agent. Your job: find the best matching label for
 - thread_id: <thread_id> (required if action is "archive")
 - desired_label: <label name — may be fuzzy, partial, or case-insensitive>
 - action: <"archive" | "mark-read" | "none">
+- labels_file: <path to cached labels JSON, optional>
 
 ## STEPS
 
-### 1. Fetch Labels
+### 1. Load Labels
 
-Run:
+If `labels_file` is provided, read labels from the cached file:
+cat <labels_file>
+
+Otherwise, fetch live:
 gws gmail labels --format json
 
-This returns all Gmail labels with id, name, and type.
+This returns all Gmail labels with id, name, and type. Using the cached file saves ~4k tokens and ~2-3s per operation.
 
 ### 2. Find Best Match
 
diff --git a/skills/morning/prompts/triage-agent.md b/skills/morning/prompts/triage-agent.md
index 2db7434..811c3bd 100644
--- a/skills/morning/prompts/triage-agent.md
+++ b/skills/morning/prompts/triage-agent.md
@@ -1,10 +1,13 @@
-# Triage Agent Prompt
-
-**Model:** `haiku` — lightweight classification only, no tool calls needed.
+---
+name: triage-agent
+model: haiku
+agent_type: general-purpose
+description: Classify emails into ACT_NOW/REVIEW/NOISE with priority scoring and label suggestions
+---
 
-**Agent type:** `general-purpose`
+# Triage Agent Prompt
 
-**Purpose:** Classify all remaining emails (after pre-filter removes OOO/invites). Returns structured classification with priority scores. Does NOT execute any gws commands — classify and return only.
+Classify all remaining emails (after pre-filter removes OOO/invites). Returns structured classification with priority scores and suggested labels. Does NOT execute any gws commands — classify and return only.
 
 Replaces the v0.2.0 batch-classifier and calendar-coordinator as a single unified agent. The v0.3.0 pre-filter script handles deterministic archiving (OOO, calendar invites). This agent handles the semantic classification that requires AI.
 
@@ -16,11 +19,18 @@ You are a triage classifier for an inbox briefing skill. You receive email summa
 ## INPUT
 
 You receive:
-- All remaining emails (pre-filtered, OOO and calendar invites already removed) with: message_id, thread_id, subject, sender, snippet, labels, message_count, date
+- **User context:** name, email, company, role/team — use this to understand what's relevant and who the user is in email threads
+- All remaining emails (pre-filtered + enriched) with: message_id, thread_id, subject, sender, snippet, labels, message_count, date, and **tags** object containing pre-computed signals:
+  - `tags.noise_signal`: "promotions" if CATEGORY_PROMOTIONS label present (strong noise indicator)
+  - `tags.vip_sender`: true if sender matches VIP list (boost priority)
+  - `tags.starred`: true if STARRED label present (boost priority to 4)
+  - `tags.is_thread`: true if multi-message thread
+  - `tags.calendar_match`: matching meeting title if subject overlaps calendar (boost priority to 4)
 - Today's meeting titles (compact — titles only, not full event objects)
 - Active task titles (compact — "Top five things" list + other active tasks)
 - OKR must-win titles (compact — objective titles only, not full sheet rows)
 - VIP senders list (email addresses)
+- **Gmail label names** (cached list — for suggesting labels on ACT_NOW and REVIEW items)
 - Config: noise_strategy, priority signals
 
 ## CLASSIFICATION CATEGORIES
@@ -76,26 +86,39 @@ Use the HIGHEST signal score (not additive).
 - MUST return structured JSON output
 - MUST process ALL emails — do not skip any
 - Single flat list — no promo vs non-promo separation
+- **Use pre-computed tags** — `tags.noise_signal`, `tags.vip_sender`, `tags.starred`, `tags.calendar_match` are deterministic signals. Trust them directly instead of re-deriving from labels or sender addresses.
 
 ## OUTPUT FORMAT
 
-Return a JSON array. For each email:
+Return a grouped JSON object with three sections. NOISE items are minimal (just IDs for bulk archive). Only ACT_NOW and REVIEW items get full details.
 
 ```json
-[
-  {
-    "message_id": "<id>",
-    "thread_id": "<id>",
-    "subject": "<subject>",
-    "sender": "<sender>",
-    "classification": "ACT_NOW | REVIEW | NOISE",
-    "priority": 1-5,
-    "summary": "1-2 line summary: what it's about, why it matters",
-    "okr_match": "<OKR objective or null>",
-    "task_match": "<task title or null>",
-    "calendar_match": "<meeting title or null>",
-    "recommended_action": "Reply to X about Y | Archive | Add task | Monitor | null"
-  }
-]
+{
+  "auto_handled": [
+    {"thread_id": "y", "reason": "noise"}
+  ],
+  "needs_input": [
+    {
+      "message_id": "x",
+      "thread_id": "y",
+      "category": "ACT_NOW",
+      "priority": 5,
+      "sender": "name <email>",
+      "subject": "Subject line",
+      "summary": "One line: why this matters",
+      "message_count": 1,
+      "matches": ["TOP 5: task name", "OKR: objective"],
+      "suggested_label": "14 - PRIVACY"
+    }
+  ],
+  "batch_stats": {"total": 10, "act_now": 2, "review": 3, "noise": 5}
+}
 ```
+
+**Rules:**
+- `auto_handled`: NOISE items only — thread_id + reason. No subject, sender, or matches.
+- `needs_input`: ACT_NOW and REVIEW items — include matches array with ONLY non-null matches (omit empty ones).
+- `matches`: compact array of strings, e.g. `["OKR: Cross-domain identity"]`. Omit the array entirely if no matches.
+- `suggested_label`: best-matching Gmail label name from the cached label list, based on email subject + sender + context. Omit if no confident match. Use exact label names from the provided list.
+- `batch_stats`: total counts. No per-email breakdown.
 ```
diff --git a/skills/morning/scripts/morning-enrich.sh b/skills/morning/scripts/morning-enrich.sh
new file mode 100755
index 0000000..11696a6
--- /dev/null
+++ b/skills/morning/scripts/morning-enrich.sh
@@ -0,0 +1,180 @@
+#!/bin/bash
+# morning-enrich.sh — Deterministic enrichment of pre-filtered emails
+#
+# Usage:
+#   morning-enrich.sh <scratchpad_dir> <config_file>
+#
+# Reads prefiltered.json (output of morning-prefilter.sh) and adds
+# deterministic tags to each email. These tags reduce AI reasoning load
+# by pre-computing signals that don't require semantic understanding.
+#
+# Input:
+#   <scratchpad_dir>/prefiltered.json — emails after OOO/invite removal
+#   <scratchpad_dir>/calendar.json — today's calendar events (optional)
+#   <config_file> — inbox-skill.yaml with VIP senders list
+#
+# Output:
+#   <scratchpad_dir>/enriched.json — emails with added tags object
+#
+# Tags added per email:
+#   noise_signal: "promotions" | null (CATEGORY_PROMOTIONS label)
+#   vip_sender: true | false (sender in VIP list from config)
+#   starred: true | false (STARRED label present)
+#   is_thread: true | false (message_count > 1)
+#   calendar_match: "<event title>" | null (fuzzy subject match)
+#
+# Requires: jq
+
+set -euo pipefail
+
+SCRATCHPAD_DIR="${1:-}"
+CONFIG_FILE="${2:-$HOME/.config/gws/inbox-skill.yaml}"
+
+if [ -z "$SCRATCHPAD_DIR" ]; then
+  echo '{"error":"Usage: morning-enrich.sh <scratchpad_dir> [config_file]"}'
+  exit 1
+fi
+
+if ! command -v jq &>/dev/null; then
+  echo '{"error":"jq is required but not found"}'
+  exit 1
+fi
+
+PREFILTERED="$SCRATCHPAD_DIR/prefiltered.json"
+CALENDAR="$SCRATCHPAD_DIR/calendar.json"
+ENRICHED="$SCRATCHPAD_DIR/enriched.json"
+
+if [ ! -f "$PREFILTERED" ]; then
+  echo '{"error":"prefiltered.json not found"}'
+  exit 1
+fi
+
+# --- Extract VIP senders from config ---
+
+VIP_SENDERS='[]'
+if [ -f "$CONFIG_FILE" ]; then
+  # Parse YAML VIP senders list (simple grep-based extraction)
+  # Note: uses [[:space:]] instead of \s for macOS sed compatibility
+  VIP_SENDERS=$(grep -A 100 'vip_senders:' "$CONFIG_FILE" 2>/dev/null | \
+    grep '^[[:space:]]*-[[:space:]]' | \
+    sed -E 's/^[[:space:]]*-[[:space:]]*//' | \
+    sed -E 's/#.*//' | \
+    sed -E 's/[[:space:]]*$//' | \
+    jq -R -s 'split("\n") | map(select(length > 0) | ascii_downcase)' 2>/dev/null || echo '[]')
+fi
+
+# --- Extract calendar event titles ---
+
+CAL_TITLES='[]'
+if [ -f "$CALENDAR" ]; then
+  CAL_TITLES=$(jq '[.events[]?.summary // empty] | map(ascii_downcase)' "$CALENDAR" 2>/dev/null || echo '[]')
+fi
+
+# --- Extract promotions and starred thread IDs from inbox labels ---
+# Labels are included in inbox data via --include-labels flag (no extra API calls needed)
+
+INBOX_FILE="$SCRATCHPAD_DIR/inbox.json"
+PROMO_IDS='[]'
+if [ -f "$INBOX_FILE" ]; then
+  PROMO_IDS=$(jq '[.threads[]? | select(.labels[]? == "CATEGORY_PROMOTIONS") | .thread_id]' "$INBOX_FILE" 2>/dev/null || echo '[]')
+fi
+
+STARRED_IDS='[]'
+if [ -f "$INBOX_FILE" ]; then
+  STARRED_IDS=$(jq '[.threads[]? | select(.labels[]? == "STARRED") | .thread_id]' "$INBOX_FILE" 2>/dev/null || echo '[]')
+fi
+
+# --- Enrich each email ---
+
+TOTAL=$(jq 'length' "$PREFILTERED")
+ENRICHED_ARRAY='[]'
+
+NOISE_COUNT=0
+VIP_COUNT=0
+STARRED_COUNT=0
+THREAD_COUNT=0
+CAL_MATCH_COUNT=0
+
+for i in $(seq 0 $((TOTAL - 1))); do
+  ENTRY=$(jq ".[$i]" "$PREFILTERED")
+
+  # Extract fields
+  SENDER=$(echo "$ENTRY" | jq -r '(.sender // .from // "") | ascii_downcase')
+  SUBJECT=$(echo "$ENTRY" | jq -r '(.subject // "") | ascii_downcase')
+  MSG_COUNT=$(echo "$ENTRY" | jq -r '.message_count // 1')
+  THREAD_ID=$(echo "$ENTRY" | jq -r '.thread_id // ""')
+
+  # --- Tag: noise_signal (via promotions query, not labels) ---
+  NOISE_SIGNAL="null"
+  if echo "$PROMO_IDS" | jq -e --arg tid "$THREAD_ID" 'index($tid) != null' >/dev/null 2>&1; then
+    NOISE_SIGNAL='"promotions"'
+    NOISE_COUNT=$((NOISE_COUNT + 1))
+  fi
+
+  # --- Tag: vip_sender ---
+  VIP="false"
+  SENDER_EMAIL=$(echo "$SENDER" | grep -oE '[a-z0-9._%+-]+@[a-z0-9.-]+' | head -1)
+  if [ -n "$SENDER_EMAIL" ]; then
+    if echo "$VIP_SENDERS" | jq -e --arg email "$SENDER_EMAIL" 'index($email) != null' >/dev/null 2>&1; then
+      VIP="true"
+      VIP_COUNT=$((VIP_COUNT + 1))
+    fi
+  fi
+
+  # --- Tag: starred (via starred query, not labels) ---
+  STARRED="false"
+  if echo "$STARRED_IDS" | jq -e --arg tid "$THREAD_ID" 'index($tid) != null' >/dev/null 2>&1; then
+    STARRED="true"
+    STARRED_COUNT=$((STARRED_COUNT + 1))
+  fi
+
+  # --- Tag: is_thread ---
+  IS_THREAD="false"
+  if [ "$MSG_COUNT" -gt 1 ] 2>/dev/null; then
+    IS_THREAD="true"
+    THREAD_COUNT=$((THREAD_COUNT + 1))
+  fi
+
+  # --- Tag: calendar_match ---
+  CAL_MATCH="null"
+  if [ "$CAL_TITLES" != "[]" ] && [ -n "$SUBJECT" ]; then
+    # Check each calendar title for word overlap with subject
+    MATCH=$(echo "$CAL_TITLES" | jq -r --arg subj "$SUBJECT" '
+      . as $titles |
+      ($subj | split(" ") | map(select(length > 3))) as $words |
+      [range(length)] |
+      map(
+        . as $idx |
+        $titles[$idx] as $title |
+        ($title | split(" ") | map(select(length > 3))) as $title_words |
+        ($words | map(. as $w | $title_words | map(select(contains($w))) | length > 0) | map(select(.)) | length) as $overlap |
+        if $overlap >= 2 then $title else empty end
+      ) | first // empty
+    ' 2>/dev/null || true)
+    if [ -n "$MATCH" ]; then
+      CAL_MATCH=$(echo "$MATCH" | jq -R '.')
+      CAL_MATCH_COUNT=$((CAL_MATCH_COUNT + 1))
+    fi
+  fi
+
+  # --- Build enriched entry ---
+  ENRICHED_ENTRY=$(echo "$ENTRY" | jq \
+    --argjson noise "$NOISE_SIGNAL" \
+    --argjson vip "$VIP" \
+    --argjson starred "$STARRED" \
+    --argjson is_thread "$IS_THREAD" \
+    --argjson cal_match "$CAL_MATCH" \
+    '. + {"tags": {"noise_signal": $noise, "vip_sender": $vip, "starred": $starred, "is_thread": $is_thread, "calendar_match": $cal_match}}')
+
+  ENRICHED_ARRAY=$(echo "$ENRICHED_ARRAY" | jq --argjson entry "$ENRICHED_ENTRY" '. + [$entry]')
+done
+
+# --- Write output ---
+
+echo "$ENRICHED_ARRAY" > "$ENRICHED"
+
+# --- Summary ---
+
+cat <<EOF
+{"total":$TOTAL,"noise_tagged":$NOISE_COUNT,"vip_tagged":$VIP_COUNT,"starred_tagged":$STARRED_COUNT,"threads_tagged":$THREAD_COUNT,"calendar_matched":$CAL_MATCH_COUNT}
+EOF
diff --git a/skills/morning/scripts/morning-prefetch.sh b/skills/morning/scripts/morning-prefetch.sh
index 652202a..d6ba7d8 100755
--- a/skills/morning/scripts/morning-prefetch.sh
+++ b/skills/morning/scripts/morning-prefetch.sh
@@ -105,7 +105,7 @@ okr_cache_fresh() {
 
 # Inbox
 (
-  gws gmail list --max "$MAX_EMAILS" --query "is:unread in:inbox" > "$OUTPUT_DIR/inbox.json" 2> "$OUTPUT_DIR/inbox.err"
+  gws gmail list --max "$MAX_EMAILS" --query "is:unread in:inbox" --include-labels > "$OUTPUT_DIR/inbox.json" 2> "$OUTPUT_DIR/inbox.err"
 ) &
 
 # Calendar