update prompt controller and loader to use new prompt files

Reviewed-on: kjannette/deClawed-Assity-Kitty#4

.gitignore

@@ -1,11 +1,12 @@
 node_modules/
 build/
 
-# OAuth secrets
-credentials.json
-credentials.*
-token*.json
-accounts.json
+# OAuth secrets (inside accountsAndCredentials/, example files are NOT ignored)
+accountsAndCredentials/credentials.json
+accountsAndCredentials/accounts.json
+accountsAndCredentials/token*.json
+accountsAndCredentials/token.json.bak
+!accountsAndCredentials/*.example.json
 
 # Runtime output
 mailSummaries/

README.md

@@ -2,241 +2,338 @@
 <img src="assets/logo.png" alt="Declawed" width="120" />
 </p>
 
+
 # Declawed: your kuddly assisty-kitty
 
-# Inbox brimming with stank-ass algorithmically-generated turds?
 
-# (Cat) nip that sh*t in the bud!!!
+Inbox brimming with stank?  Wanna cut the crap and get the messaging that matters into calendars, Atlassian, Jira, Asana, Google Calendar/Sheets (etc.) ... in two clicks?  (Cat) nip slop in the bud with Assisty-Kitty!!
 
-###  Declawed is a configurable, prompt purrr-fectable LLM mail management assisty-kitty.
-###  Puuurfect for tedious daily sorts/classification/responses
-###  Cuts down on the frustartion of feeling like you'll never get your paws on that catnip-stuffed mouse dangling from the string.
 
-# Privacy
+# The "why":
 
-# More than the blue-plate crustacean
 
-A local Model Context Protocol (MCP) server integrates with an LLM API you choose -- both of which offer greater ops and privacy control and transparency.
+### Eliminates that frustrating feeling you'll never get your paws around the dangling, catnip-stuffed mouse through haunch-high mail from list you're never signed up for or were re-sold to from ones you have, bot-generated marketing slop, and, of course, nigerians princes that need help claim their lottery jackpot.
 
-# Avoid flakey (molty?) black box installs.
 
-Billed as QUICK AND EASY! ...loaded with  more Trojans than an Olympic Village.
-... Silent processes: data harvest phone-homes, behavioral analytic reporting, telemetry backdoors - all the nasties crawling the dark detritus.  You know lobsters eat poop, right?
+"deClawed" because: no one should be beholden to one LLM api or local model.  Have you seen that baddie Kimi K3? 
 
-# Declawed: **actually** easy
 
-## Stop drilling byzantine menus in mail, scehduling and sheets pltforms to 1. configure filters that don't even work 2. change every three months
+The platform princes are rent extractors.
 
-## Short, declarative prompts are teh equivelent of wrapping slop, bulk-mail's feet in tin foil and tossing it in the bathtub.
 
-###  Prompts are discerning, unlike filters.  For exaple, they keep the gold and bin the junk in forums/feeds where solid-gold insights are only 10% of the signal/noise.
-### With refinement, prompting runs auto: cleaning that stank litter(in)box before you get a whiff.
-### Morning greets you with a fresh, spring-meadow aroma of opportunities and insights -- not an avalanche of turds -- like its f*cxing 1998 again.
+Open weights are heavy weight champions.
+
+
+# The "how"
+
+
+Because It's soooo easy.
+deClawed is configurable, prompt purrr-fectable, LLM-driven mail and task automation for anyone that can cut n' paste a few CLI commands and can type in short declarative sentences.
+More private than other options (not purrfect *yet* - but privacy is our number one goal with every release).
+More accurate actions/results (read on).
+
+
+# Privacy: more than the blue-plate crustacean
+
+
+Your own local Model Context Protocol (MCP) server integrates with your preferred LLM API. Each step in the install, and setup offers greater control, and transparency.  Permissions are 100% configurable.
+
+
+Escape black-box installs stocked with more Trojans than an Olympic Village - silent/dark processes, data harvesting phone-homes, behavioral analytics, telemetry backdoors, corporate surveillance - the nasties lurking in the dark discoverable only by secops edgelords that are masters of the the CLI.
+
+
+# Simplicity
+
+
+### NLP prompts are **actually** easy and  **demonstrably**  more effective
+
+
+Stop drilling down byzantine menus in mail, scheduling and workflow to configure filters and actions that 1. only ever work 20% of the time 2. change in functionality and scope every two months because a project manager needs to justify their salary.
+
+
+Write short, declarative prompts instead. It's like wrapping busywork's paws in tinfoil and tossing it in a bathtub.
+
+
+Prompts
+
+
+1. Use semantic grouping, organizing by message intent, purpose, and context.
+2. The prompt templates in Kitty's "built in" library are evaluated using, for example, cosine similarity, ROUGE scoring and real human eval in the SDLC dev loop.
+3. For example: you'll consistently keep the treasure and trash the junk when you task deClawed with reviewing forums/feeds where actionable insights are gold, but only 10% of the signal.
+
+
+### Prompting: easily configured to cron: cleaning the litter(in)box before the stank wafts through the whole work house.
+### Imagine your morning inbox or summaries brimming with a fresh, spring-meadow aroma of opportunity and insight -- not last night's Kitty kibble.
+
+
+# -- You just might feel like it' s freakin' 1998 again.
+
+
+# Wiring up your kitty
+
+
+Assisty-kitty easily interfaces with mail and calendar and other app APIs (about any other service you want to plug in) ... it keeps things moving so you can go chase laser pointers or enjoy a 19-hour nap in a sunbeam.
 
-# Kitty connex are simple
-Assisty-kitty easily interfaces with mail and calendar and other app APIs (about any other service you want to plug in) ... it keeps things moving so you can go you chase your tail or take a 19-hour nap in a sunbeam.
 
 ---
 
+
 # Scope and Architecture
 
+
 ## Current implementation requires building/using:
--- Claude Desktop (as UI - proprietary UI coming soonish)
--- Building/Connecting a Local Model Context Protocol Server
+-- Claude Desktop (as UI only - proprietary UI coming soonish)
+-- Building/Connecting a Model API or Local Model Context Protocol Server
 -- A DNS-config’d domain, with MX records pointing to:
--- A commercial or self-hosted SMTP Serve
+-- A commercial or self-hosted SMTP Server
+
 
 ## Coming soonish:
--- Our own custom UI
--- Suppost for wiring up local LLMs.
+-- Proprietary, custom UI.
+-- Support for all stripes of models on HugginFFace.
+- Support for local LLMs.
+
 
 # Setup
 
+
 ### 1. Install Node.js (v16+ required).
 
+
 ```bash
 node --version
 npm --version
 ```
 
+
 If not installed, grab it from [nodejs.org](https://nodejs.org/).
 
+
 ### 2. Clone and Install
 
-```bash
-git clone https://github.com/kjannette/deClawed-Assisty-Kitty.git
-cd deClawed-Assity-Kitty
-npm install
-```
 
+```bash
+git clone https://git.sjdev.online/kjannette/deClawed-Assity-Kitty
+cd deClawed-Assity-Kitty
+npm i
+```
 ### 3. Set Up Google Cloud Credentials
 
+
 #### 3a. Create a Google Cloud Project
 
+
 1. Go to [Google Cloud Console](https://console.cloud.google.com/)
 2. Sign in with the Google account that owns the target Gmail
 3. Click the project dropdown (top-left) > **New Project**
 4. Name it (e.g., `assistant-mcp`) and click **Create**
 5. Select the new project from the dropdown
 
+
 #### 3b. Enable APIs
 
+
 In **APIs & Services > Library**, enable:
 - **Gmail API**
 - **Google Sheets API** (if mapping mail to sheets)
 - **Google Calendar API** (if using calendar event creation, etc.s)
 
+
 #### 3c. Configure the OAuth Consent Screen
 
+
 1. Go to **Google Auth Platform > Branding** (or **APIs & Services > OAuth consent screen**)
 2. Set user type to **External**, click **Create**
 3. Fill in app name, support email, and developer contact email
 4. Save and continue
 
+
 #### 3d. Add OAuth Scopes
 
+
 In **Google Auth Platform > Data Access**, add:
 - `https://www.googleapis.com/auth/gmail.modify`
 - `https://www.googleapis.com/auth/spreadsheets` (for Sheets integration)
 - `https://www.googleapis.com/auth/calendar.events` (for Calendar integration)
 
+
 #### 3e. Add Yourself as a Test User
 
+
 Go to **Google Auth Platform > Audience** and add each Gmail address you'll use.
 
+
 #### 3f. Create OAuth Client Credentials
 
+
 1. Go to **Google Auth Platform > Clients** (or **APIs & Services > Credentials**)
 2. Click **Create Client** > Application type: **Desktop app**
 3. **Download the JSON**, rename it to `credentials.json`
 4. Place it in the project root
 
+
 ### 4. Configure Accounts
 
+
 Create file `accounts.json` in the project root. Each key is an account alias with its own token file and optional Sheets/Calendar config:
 
+
 ```json
 {
 "work": {
- "label": "you@yourdomain.com",
- "tokenFile": "token.json",
- "spreadsheetId": "YOUR_GOOGLE_SHEET_ID",
- "calendarId": "primary"
+"label": "you@yourdomain.com",
+"tokenFile": "token.json",
+"spreadsheetId": "YOUR_GOOGLE_SHEET_ID",
+"calendarId": "primary"
 },
 "secondary": {
- "label": "you@gmail.com",
- "tokenFile": "token-secondary.json"
+"label": "you@gmail.com",
+"tokenFile": "token-secondary.json"
 }
 }
 ```
 
+
 - **`label`** -- display name (typically the email address)
 - **`tokenFile`** -- per-account OAuth token (auto-generated during auth)
 - **`spreadsheetId`** -- Google Sheets ID for recruiter contact logging (optional)
 - **`calendarId`** -- Google Calendar ID for event creation (optional, `"primary"` uses the default calendar)
 
+
 ### 5. Authorize Gmail Accounts
 
+
 Build and run the auth script for each account:
 
+
 ```bash
 npm run auth              # authorizes the "work" account
 npm run auth -- secondary # authorizes the "secondary" account
 ```
 
-Each run will:
+
+Each run required steps:
+
+
 1. Print a URL -- open it in your browser
 2. Sign in and click **Allow**
 3. You'll land on a "localhost refused to connect" page (normal)
 4. Copy the **entire URL** from the address bar and paste it back into the terminal
 5. The script saves the token file (e.g., `token.json` or `token-secondary.json`)
 
+
 You only need to do this once per account. Tokens auto-refresh.
 
+
 ### 6. Write the Prompts
 
+
 Two plain-text prompt files in `src/prompts/` control the workflow:
 
+
 | File | Phase | Purpose |
 |------|-------|---------|
 | `src/prompts/classify-emails.txt` | 1 -- Classification | Defines categories A/B/C/D and how to sort emails |
-| `src/prompts/take-action-on-emails.txt` | 2 -- Action | Tells the LLM what to do with each category (delete, log, schedule, etc.) |
+| `src/prompts/take-action-on-emails.txt` | 2 -- Action | Tell the LLM what to do with each category (delete, log, schedule, etc.) |
+
 
 **Tips:**
+
+
 - Use clear, explicit category definitions with example language
 - Handle ambiguous cases (e.g., "If an email both acknowledges receipt AND requests action, classify as B")
 - Prompt files are loaded at runtime -- edit them anytime, no rebuild required
 
+
 ### 7. Build
 
+
 ```bash
 npm run build
 ```
 
+
 Compiles `src/**/*.ts` into `build/`.
 
+
 ## 8. Configure Claude Desktop
 
+
 Edit your Claude Desktop config:
 
+
 ```bash
 code ~/Library/Application\ Support/Claude/claude_desktop_config.json
 ```
 
+
 Add the server:
 
+
 ```json
 {
 "mcpServers": {
- "assistant": {
-   "command": "/ABSOLUTE/PATH/TO/node",
-   "args": [
-     "/ABSOLUTE/PATH/TO/deClawed-Assity-Kitty/build/index.js"
-   ]
- }
+"assistant": {
+"command": "/ABSOLUTE/PATH/TO/node",
+"args": [
+  "/ABSOLUTE/PATH/TO/deClawed-Assity-Kitty/build/index.js"
+]
+}
 }
 }
 ```
 
+
 Replace paths with the output of `which node` and your actual project location.
 
+
 ## 9. Add/Configure API Keys, Credentials, and Other Secrets
 
+
 Secret files are **gitignored** -- they never leave your machine. Example templates are provided so you know what shape each file needs to be in.
 
+
 #### 9a. `credentials.json`
 
+
 This file holds your Google OAuth client credentials. **You do not write this by hand** -- it is downloaded from the Google Cloud Console (see Step 3f above). Copy the example and then replace it with the real download:
 
+
 ```bash
 cp credentials.example.json credentials.json
 # Now replace credentials.json with the file downloaded from Google Cloud Console.
 ```
 
+
 The structure looks like this (the example file ships with empty values):
 
+
 ```json
 {
- "installed": {
-   "client_id": "",
-   "project_id": "",
-   "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-   "token_uri": "https://oauth2.googleapis.com/token",
-   "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
-   "client_secret": "",
-   "redirect_uris": ["http://localhost"]
- }
+"installed": {
+"client_id": "",
+"project_id": "",
+"auth_uri": "https://accounts.google.com/o/oauth2/auth",
+"token_uri": "https://oauth2.googleapis.com/token",
+"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+"client_secret": "",
+"redirect_uris": ["http://localhost"]
+}
 }
 ```
 
+
 #### 9b. `accounts.json`
 
+
 Defines each Gmail account the server manages. Copy the example and fill in your values:
 
+
 ```bash
 cp accounts.example.json accounts.json
 ```
 
+
 | Field | What to put here |
 |-------|-----------------|
 | `label` | The email address for this account (display only) |
@@ -244,28 +341,38 @@ cp accounts.example.json accounts.json
 | `spreadsheetId` | The ID from your Google Sheet URL: `docs.google.com/spreadsheets/d/<THIS_PART>/edit` (optional) |
 | `calendarId` | `"primary"` for your default calendar, or a specific calendar ID (optional) |
 
+
 Add as many accounts as you need. Each key (e.g., `"work"`, `"secondary"`) becomes the account name used in tool calls and auth commands.
 
+
 #### 9c. `token*.json` (auto-generated)
 
+
 Token files are **created automatically** when you run `npm run auth` (Step 5). You do not need to create or edit them manually. A `token.example.json` is provided for reference only -- it shows the structure but the values are populated by the OAuth flow.
 
+
 #### Summary of secret files
 
+
 | Example template | Actual file (gitignored) | How to create |
 |-----------------|--------------------------|---------------|
 | `credentials.example.json` | `credentials.json` | Download from Google Cloud Console |
 | `accounts.example.json` | `accounts.json` | Copy example, fill in your email/sheet/calendar IDs |
 | `token.example.json` | `token.json`, `token-secondary.json`, etc. | Auto-generated by `npm run auth` |
 
+
 ### 10. Restart Claude Desktop
 
+
 Fully quit (**Cmd+Q**, not just close the window) and reopen. The `assistant` server should appear under **Connectors**.
 
+
 ---
 
+
 ## MCP Tools
 
+
 | Tool | Description |
 |------|-------------|
 | `fetch_new_emails` | Fetches unread emails for a given account. Classification and action prompts are automatically appended to the response. |
@@ -274,24 +381,32 @@ Fully quit (**Cmd+Q**, not just close the window) and reopen. The `assistant` se
 | `log_contact` | Logs or updates contact info in a Google Sheet. Merges rows by email + role. |
 | `create_calendar_event` | Creates a Google Calendar event for scheduled calls/meetings. Includes meeting links, attendees and their contact info. |
 
+
 ## MCP Prompts (built in as of now-ish - add your own)
 ### BETTER YET - DO A PR OR FORK
 
+
 | Prompt | Account | Description |
 |--------|---------|-------------|
 | `review_emails` | work | Loads the classification + action prompts for the work inbox |
 | `review_secondary_emails` | secondary | Same workflow, but for a second email account inbox |
 
+
 Invoke these from Claude Desktop's Connectors menu, or just type "Review my inbox" / "Review my secondary inbox."
 
+
 ---
 
+
 ## Two-Phase Workflow
 
+
 **Phase 1 -- Classify**
 
+
 The LLM calls `fetch_new_emails`, which returns email data with the classification instructions from `classify-emails.txt` appended. Each email is sorted into:
 
+
 | Category | Meaning | Action |
 |----------|---------|--------|
 | **A** | Acknowledgement / auto-reply | Delete |
@@ -299,18 +414,23 @@ The LLM calls `fetch_new_emails`, which returns email data with the classificati
 | **C** | Rejection | Delete |
 | **D** | Other / uncategorized | Summarize + log |
 
+
 **Phase 2 -- Act**
 
+
 Using `take-action-on-emails.txt`, the LLM:
 - Calls `delete_emails` for A + C
 - Calls `append_to_summary` for B + D
 - Calls `log_recruiter_contact` to track contacts in Sheets (if configured)
 - Calls `create_calendar_event` for any scheduled interviews/calls (if configured)
 
+
 ---
 
+
 ## Key Commands
 
+
 | Command | Purpose |
 |---------|---------|
 | `npm run build` | Recompile after editing source files |
@@ -319,10 +439,13 @@ Using `take-action-on-emails.txt`, the LLM:
 | `npm test` | Run the test suite |
 | `npm run test:watch` | Run tests in watch mode |
 
+
 ---
 
+
 ## Project Structure
 
+
 ```
 deClawed-Assity-Kitty/
 ├── src/
@@ -340,6 +463,14 @@ deClawed-Assity-Kitty/
 │       ├── tools-email.ts               # fetch, delete, append_to_summary
 │       ├── tools-calendar.ts            # create_calendar_event
 │       └── tools-spreadsheet.ts         # log_recruiter_contact
+├── accountsAndCredentials/
+│   ├── accounts.json                    # Multi-account configuration (gitignored)
+│   ├── accounts.example.json            # Template for accounts.json
+│   ├── credentials.json                 # Google OAuth client credentials (gitignored)
+│   ├── credentials.example.json         # Template for credentials.json
+│   ├── token.json                       # OAuth token -- work account (gitignored, auto-generated)
+│   ├── token-secondary.json             # OAuth token -- secondary account (gitignored, auto-generated)
+│   └── token.example.json              # Template showing token structure
 ├── test/
 │   ├── fixtures/
 │   │   └── mock-emails.ts              # Mock Gmail API responses
@@ -347,21 +478,13 @@ deClawed-Assity-Kitty/
 │   │   └── email-workflow.test.ts       # Integration tests
 │   └── unit/
 │       └── email-parsing.test.ts        # Unit tests for parsing helpers
-├── mailSummaries/                       # Per-account summary output (auto-generated)
+├── mailSummaries/                       # Per-account summary output (gitignored, auto-generated)
 ├── build/                               # Compiled JS (auto-generated)
-├── accounts.json                        # Multi-account configuration
-├── credentials.json                     # Google OAuth client credentials
-├── token*.json                          # Per-account OAuth tokens (auto-generated)
+├── assets/
+│   └── logo.png                         # Project logo
 ├── package.json
 ├── tsconfig.json
 ├── vitest.config.ts
+├── .gitignore
 └── README.md
 ```
-
-
-
-
-
-
-
-

accountsAndCredentials/credentials.example.json

@@ -0,0 +1,11 @@
+{
+  "installed": {
+    "client_id": "",
+    "project_id": "",
+    "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+    "token_uri": "https://oauth2.googleapis.com/token",
+    "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+    "client_secret": "",
+    "redirect_uris": ["http://localhost"]
+  }
+}

accountsAndCredentials/token.example.json

@@ -0,0 +1,7 @@
+{
+  "access_token": "",
+  "refresh_token": "",
+  "scope": "https://www.googleapis.com/auth/spreadsheets https://www.googleapis.com/auth/gmail.modify https://www.googleapis.com/auth/calendar.events",
+  "token_type": "Bearer",
+  "expiry_date": 0
+}

package-lock.json

@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
-        "@modelcontextprotocol/sdk": "^1.26.0",
+        "@modelcontextprotocol/sdk": "^1.30.0",
         "googleapis": "^171.4.0",
         "zod": "^3.25.76"
       },
@@ -501,12 +501,12 @@
       "license": "MIT"
     },
     "node_modules/@modelcontextprotocol/sdk": {
-      "version": "1.26.0",
-      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.26.0.tgz",
-      "integrity": "sha512-Y5RmPncpiDtTXDbLKswIJzTqu2hyBKxTNsgKqKclDbhIgg1wgtf1fRuvxgTnRfcnxtvvgbIEcqUOzZrJ6iSReg==",
+      "version": "1.30.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.30.0.tgz",
+      "integrity": "sha512-xKd8OIzlqNzcqcNumGAa6g+PW2kjD5vrpcKOnfldAUPP3j7lnqMPwlTXQm8gF+UwH72z0lqaRbjr9hqGz0eITA==",
       "license": "MIT",
       "dependencies": {
-        "@hono/node-server": "^1.19.9",
+        "@hono/node-server": "^1.19.9 || ^2.0.5",
         "ajv": "^8.17.1",
         "ajv-formats": "^3.0.1",
         "content-type": "^1.0.5",

package.json

@@ -19,7 +19,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "googleapis": "^171.4.0",
     "zod": "^3.25.76"
   },

src/auth.ts

@@ -5,8 +5,9 @@ import readline from "readline";
 
 const __dirname = path.dirname(new URL(import.meta.url).pathname);
 const PROJECT_ROOT = path.resolve(__dirname, "..");
-const CREDENTIALS_PATH = path.join(PROJECT_ROOT, "credentials.json");
-const ACCOUNTS_PATH = path.join(PROJECT_ROOT, "accounts.json");
+const SECRETS_DIR = path.join(PROJECT_ROOT, "accountsAndCredentials");
+const CREDENTIALS_PATH = path.join(SECRETS_DIR, "credentials.json");
+const ACCOUNTS_PATH = path.join(SECRETS_DIR, "accounts.json");
 
 const SCOPES = [
   "https://www.googleapis.com/auth/gmail.modify",
@@ -26,7 +27,7 @@ function resolveTokenPath(accountKey: string): string {
       `Unknown account "${accountKey}". Available: ${available}`
     );
   }
-  return path.join(PROJECT_ROOT, acct.tokenFile);
+  return path.join(SECRETS_DIR, acct.tokenFile);
 }
 
 async function authorize(): Promise<void> {
@@ -44,7 +45,7 @@ async function authorize(): Promise<void> {
         "1. Go to https://console.cloud.google.com/\n" +
         "2. Create a project and enable the Gmail, Sheets, and Calendar APIs\n" +
         "3. Create OAuth 2.0 credentials (Desktop app type)\n" +
-        "4. Download the JSON and save it as credentials.json in the project root\n"
+        "4. Download the JSON and save it as credentials.json in the accountsAndCredentials/ folder\n"
     );
     process.exit(1);
   }

src/loaders/prompt-config-loaders.ts

@@ -3,147 +3,149 @@ import { google, gmail_v1, sheets_v4, calendar_v3 } from "googleapis";
 import { OAuth2Client } from "google-auth-library";
 import fs from "fs";
 import path from "path";
-
+import { fileURLToPath } from "url";
 // ---------------------------------------------------------------------------
 // Paths
 // ---------------------------------------------------------------------------
-const __dirname = path.dirname(new URL(import.meta.url).pathname);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 export const PROJECT_ROOT = path.resolve(__dirname, "..", "..");
-const CREDENTIALS_PATH = path.join(PROJECT_ROOT, "credentials.json");
-const ACCOUNTS_PATH = path.join(PROJECT_ROOT, "accounts.json");
-const CLASSIFY_PROMPT_PATH = path.join(PROJECT_ROOT, "classify-emails.txt");
-const ACTION_PROMPT_PATH = path.join(
-  PROJECT_ROOT, "src", "prompts", "take-action-on-emails.txt"
-);
+const SECRETS_DIR = path.join(PROJECT_ROOT, "accountsAndCredentials");
+const CREDENTIALS_PATH = path.join(SECRETS_DIR, "credentials.json");
+const ACCOUNTS_PATH = path.join(SECRETS_DIR, "accounts.json");
+const PROMPTS_DIR = path.join(PROJECT_ROOT, "src", "prompts");
+const CLASSIFY_PROMPT_PATH = path.join(PROMPTS_DIR, "classify-emails.txt");
+const ACTION_PROMPT_PATH = path.join(PROMPTS_DIR, "take-action-on-emails.txt");
 
 // ---------------------------------------------------------------------------
 // Account configuration
 // ---------------------------------------------------------------------------
 export interface AccountConfig {
-  label: string;
-  tokenFile: string;
-  spreadsheetId?: string;
-  calendarId?: string;
+    label: string;
+    tokenFile: string;
+    spreadsheetId?: string;
+    calendarId?: string;
 }
 
 export interface AccountsMap {
-  [key: string]: AccountConfig;
+    [key: string]: AccountConfig;
 }
 
 export const loadAccounts = (): AccountsMap => {
-  if (!fs.existsSync(ACCOUNTS_PATH)) {
-    throw new Error(`Missing accounts.json at ${ACCOUNTS_PATH}.`);
-  }
-  return JSON.parse(fs.readFileSync(ACCOUNTS_PATH, "utf-8"));
+    if (!fs.existsSync(ACCOUNTS_PATH)) {
+        throw new Error(`Missing accounts.json at ${ACCOUNTS_PATH}.`);
+    }
+    return JSON.parse(fs.readFileSync(ACCOUNTS_PATH, "utf-8"));
 };
 
 export const getTokenPath = (account: string): string => {
-  const accts = loadAccounts();
-  const acct = accts[account];
-  if (!acct) {
-    const available = Object.keys(accts).join(", ");
-    throw new Error(
-      `Unknown account "${account}". Available accounts: ${available}`
-    );
-  }
-  return path.join(PROJECT_ROOT, acct.tokenFile);
+    const accts = loadAccounts();
+    const acct = accts[account];
+    if (!acct) {
+        const available = Object.keys(accts).join(", ");
+        throw new Error(
+            `Unknown account "${account}". Available accounts: ${available}`
+        );
+    }
+    return path.join(SECRETS_DIR, acct.tokenFile);
 };
 
 export const getSummaryPath = (account: string): string => {
-  if (account === "work") {
-    return path.join(PROJECT_ROOT, "mailSummaries", "summary.json");
-  }
-  return path.join(PROJECT_ROOT, "mailSummaries", `summary-${account}.json`);
+    if (account === "work") {
+        return path.join(PROJECT_ROOT, "mailSummaries", "summary.json");
+    }
+    return path.join(PROJECT_ROOT, "mailSummaries", `summary-${account}.json`);
 };
 
 export const VALID_ACCOUNTS = ["work", "secondary"] as const;
 export const accounts = loadAccounts();
 
 const accountDescription = VALID_ACCOUNTS
-  .map((key) => `"${key}" (${accounts[key]?.label ?? key})`)
-  .join(" or ");
+    .map((key) => `"${key}" (${accounts[key]?.label ?? key})`)
+    .join(" or ");
 
 export const accountSchema = z
-  .enum(VALID_ACCOUNTS)
-  .describe(`Which email account to use: ${accountDescription}`);
+    .enum(VALID_ACCOUNTS)
+    .describe(`Which email account to use: ${accountDescription}`);
 
 // ---------------------------------------------------------------------------
 // Prompt loaders
 // ---------------------------------------------------------------------------
 const loadPromptFile = (filePath: string, label: string): string => {
-  if (!fs.existsSync(filePath)) {
-    console.error(`Warning: ${filePath} not found. ${label} will be missing.`);
-    return "";
-  }
-  return fs.readFileSync(filePath, "utf-8");
+    if (!fs.existsSync(filePath)) {
+        console.error(`Warning: ${filePath} not found. ${label} will be missing.`);
+        return "";
+    }
+    return fs.readFileSync(filePath, "utf-8");
 };
 
 export const loadClassificationPrompt = (): string =>
-  loadPromptFile(CLASSIFY_PROMPT_PATH, "Classification instructions");
+    loadPromptFile(CLASSIFY_PROMPT_PATH, "Classification instructions");
 
 export const loadActionPrompt = (): string =>
-  loadPromptFile(ACTION_PROMPT_PATH, "Action instructions");
+    loadPromptFile(ACTION_PROMPT_PATH, "Action instructions");
 
 // ---------------------------------------------------------------------------
 // Auth helpers — generic OAuth2 client, then service-specific factories
 // ---------------------------------------------------------------------------
 export const getOAuth2Client = (account: string): OAuth2Client => {
-  const tokenPath = getTokenPath(account);
+    const tokenPath = getTokenPath(account);
 
-  if (!fs.existsSync(CREDENTIALS_PATH)) {
-    throw new Error(
-      `Missing credentials.json at ${CREDENTIALS_PATH}. Run "npm run auth" first.`
+    if (!fs.existsSync(CREDENTIALS_PATH)) {
+        throw new Error(
+            `Missing credentials.json at ${CREDENTIALS_PATH}. Run "npm run auth" first.`
+        );
+    }
+    if (!fs.existsSync(tokenPath)) {
+        throw new Error(
+            `Missing token file at ${tokenPath} for account "${account}". Run "npm run auth" first.`
+        );
+    }
+
+    const credentials = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf-8"));
+    const { client_id, client_secret, redirect_uris } =
+        credentials.installed || credentials.web;
+
+    const oAuth2Client = new google.auth.OAuth2(
+        client_id,
+        client_secret,
+        redirect_uris[0]
     );
-  }
-  if (!fs.existsSync(tokenPath)) {
-    throw new Error(
-      `Missing token file at ${tokenPath} for account "${account}". Run "npm run auth" first.`
-    );
-  }
 
-  const credentials = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf-8"));
-  const { client_id, client_secret, redirect_uris } =
-    credentials.installed || credentials.web;
+    const token = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
+    oAuth2Client.setCredentials(token);
 
-  const oAuth2Client = new google.auth.OAuth2(
-    client_id,
-    client_secret,
-    redirect_uris[0]
-  );
+    oAuth2Client.on("tokens", (newTokens) => {
+        const current = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
+        fs.writeFileSync(
+            tokenPath,
+            JSON.stringify({ ...current, ...newTokens }, null, 2)
+        );
+        console.error(`Token refreshed and saved for account "${account}".`);
+    });
 
-  const token = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
-  oAuth2Client.setCredentials(token);
-
-  oAuth2Client.on("tokens", (newTokens) => {
-    const current = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
-    fs.writeFileSync(
-      tokenPath,
-      JSON.stringify({ ...current, ...newTokens }, null, 2)
-    );
-    console.error(`Token refreshed and saved for account "${account}".`);
-  });
-
-  return oAuth2Client;
+    return oAuth2Client;
 };
 
 export const getGmailClient = (account: string): gmail_v1.Gmail =>
-  google.gmail({ version: "v1", auth: getOAuth2Client(account) });
+    google.gmail({ version: "v1", auth: getOAuth2Client(account) });
 
 export const getSheetsClient = (account: string): sheets_v4.Sheets =>
-  google.sheets({ version: "v4", auth: getOAuth2Client(account) });
+    google.sheets({ version: "v4", auth: getOAuth2Client(account) });
 
 export const getCalendarClient = (account: string): calendar_v3.Calendar =>
-  google.calendar({ version: "v3", auth: getOAuth2Client(account) });
+    google.calendar({ version: "v3", auth: getOAuth2Client(account) });
 
 export const getSpreadsheetId = (account: string): string => {
-  const acct = accounts[account];
-  if (!acct?.spreadsheetId || acct.spreadsheetId === "PASTE_YOUR_SHEET_ID_HERE") {
-    throw new Error(
-      `No spreadsheetId configured for account "${account}" in accounts.json.`
-    );
-  }
-  return acct.spreadsheetId;
+    const acct = accounts[account];
+    if (!acct?.spreadsheetId || acct.spreadsheetId === "PASTE_YOUR_SHEET_ID_HERE") {
+        throw new Error(
+            `No spreadsheetId configured for account "${account}" in accounts.json.`
+        );
+    }
+    return acct.spreadsheetId;
 };
 
 export const getCalendarId = (account: string): string =>
-  accounts[account]?.calendarId ?? "primary";
+    accounts[account]?.calendarId ?? "primary";

src/prompt-controller-service/prompt-controller-service.ts

@@ -1,64 +1,56 @@
 import { server } from "../McpServer.js";
 import {
-  accounts,
-  loadClassificationPrompt,
-  loadActionPrompt,
+    accounts,
+    loadClassificationPrompt,
+    loadActionPrompt,
 } from "../loaders/prompt-config-loaders.js";
 
 // ---------------------------------------------------------------------------
-// Prompt: review_emails (work account)
+// Prompt: Classify Emails (Phase 1)
 // ---------------------------------------------------------------------------
 server.registerPrompt(
-  "review_emails",
-  {
-    description:
-      `Review WORK inbox (${accounts.work?.label ?? "work"}): classify emails, delete A+C, summarize B+D, log B to spreadsheet, create calendar events.`,
-  },
-  () => {
-    const phase1 = loadClassificationPrompt();
-    const phase2 = loadActionPrompt();
-    return {
-      messages: [
-        {
-          role: "user" as const,
-          content: {
-            type: "text" as const,
-            text:
-              `ACCOUNT: Use account = "work" for ALL tool calls in this session.\n\n` +
-              (phase1 || "Review my new emails and classify them by job application category.") +
-              (phase2 ? `\n\n${phase2}` : ""),
-          },
-        },
-      ],
-    };
-  }
+    "classify-emails",
+    {
+        description: "Phase 1: Organize, prioritize, and summarize incoming recruiter emails.",
+    },
+    () => {
+        const phase1 = loadClassificationPrompt();
+        return {
+            messages: [
+                {
+                    role: "user" as const,
+                    content: {
+                        type: "text" as const,
+                        text: `ACCOUNT: Use account = "work" for ALL tool calls in this session.\n\n` +
+                            (phase1 || "Review my new emails and classify them by job application category.")
+                    },
+                },
+            ],
+        };
+    }
 );
 
 // ---------------------------------------------------------------------------
-// Prompt: review_secondary_emails (secondary account)
+// Prompt: Take Action on Emails (Phase 2)
 // ---------------------------------------------------------------------------
 server.registerPrompt(
-  "review_secondary_emails",
-  {
-    description:
-      `Review SECONDARY inbox (${accounts.secondary?.label ?? "secondary"}): classify emails, delete A+C, summarize B+D, log B to spreadsheet, create calendar events.`,
-  },
-  () => {
-    const phase1 = loadClassificationPrompt();
-    const phase2 = loadActionPrompt();
-    return {
-      messages: [
-        {
-          role: "user" as const,
-          content: {
-            type: "text" as const,
-            text:
-              `ACCOUNT: Use account = "secondary" for ALL tool calls in this session.\n\n` +
-              (phase1 || "Review my new emails and classify them by job application category.") +
-              (phase2 ? `\n\n${phase2}` : ""),
-          },
-        },
-      ],
-    };
-  }
+    "take-action-on-emails",
+    {
+        description: "Phase 2: Log Category B recruiters to spreadsheet and create calendar events.",
+    },
+    () => {
+        const phase2 = loadActionPrompt();
+        return {
+            messages: [
+                {
+                    role: "user" as const,
+                    content: {
+                        type: "text" as const,
+                        text: `ACCOUNT: Use account = "work" for ALL tool calls in this session.\n\n` +
+                            (phase2 || "Process remaining action items for flagged recruiters.")
+                    },
+                },
+            ],
+        };
+    }
 );

src/prompts/classify-emails.txt

@@ -1,12 +1,11 @@
-You are an expert Executive Assistant AI specialized in email management and productivity. Your goal is to organize, prioritize, and summarize incoming emails to maximize user efficiency.
+You are an expert Executive Assistant AI specialized in email management and productivity. Your goal is to organize, prioritize, and summarize incoming emails to maximize user efficiency. I have been applying for jobs, which generates a large volume of responses. 
 
-I have been applying for jobs, which generates a large volume of responses. Review my inbox and apply the following instructions to all new emails.
+Review the first 200 emails in my inbox. Apply the following instructions to those emails.
 
 STEP 1: Constraints
 - Do not make up information.
 
 STEP 2: CLASSIFY each email into exactly one category.
-
 Category A - Acknowledgement Only
 The employer confirms receipt of my application but requires no action from me. Typical language: "We received your application," "Your application is under review," "We will contact you if selected." No next steps are requested.
 
@@ -19,11 +18,13 @@ The employer declines to move forward. Typical language: "We have decided to pur
 Category D - Other
 The email does not fit into categories A, B, or C. This includes non-job-application emails, newsletters, promotional content, or ambiguous messages that do not clearly match another category.
 
-STEP 3: DELETE emails classified as Category A and Category C.
+STEP 3: STAR REVIEWED EMAILS
+- For EVERY single email processed and reviewed in this run (Categories A, B, C, and D), apply the Gmail "STARRED" system label or use your email tool to add a star to the message. 
 
-STEP 4: ("Anti step") -  NEVER DELETE Category B emails.
+STEP 4: Confirm, via natural language output in the chat window, the total number of emails fetched for review and successfully starred.
 
-STEP 5: SUMMARIZE emails classified as Category B and Category D. For each, include:
+STEP 5: SUMMARIZE emails classified as Category B and Category D.
+For each, state:
 1. Sender name and email address
 2. Email subject line
 3. Date and time received

src/prompts/take-action-on-emails.txt

@@ -1,12 +1,9 @@
 PHASE 2: TAKE ACTION ON CATEGORY B EMAILS
-
 After completing classification (Phase 1), perform the following actions for each email classified as Category B (Advancement to Next Step).
 
 STEP 1: LOG TO SPREADSHEET
 For each Category B email, extract as much of the following information as possible from the email contents and log it using the log_recruiter_contact tool:
-
 A column exists for:
-
 - Recruiter Name
 - Recruiter Email
 - Recruiter Phone/Tel
@@ -15,7 +12,7 @@ A column exists for:
 - Subsequent Contacts: any follow-up communication with this recruiter about this role
 - Recruiter Call Scheduled: if the email contains scheduling information, extract ALL details — date, time, platform (Zoom, MS Teams, Google Meet, etc.), meeting link, phone number to call — and note whether they confirm having your cell number or might not have it
 
-A row should already exists for the same recruiter email + company/role combination (from a previous email), the tool will UPDATE the existing row. Provide all available fields and the tool handles merging.
+If a row already exists for the same recruiter email + company/role combination (from a previous email), the tool will UPDATE the existing row. Provide all available fields and the tool handles merging.
 
 STEP 2: CREATE CALENDAR EVENTS
 Immediately after logging to the spreadsheet, check whether ANY of these fields were populated or updated:
@@ -24,7 +21,7 @@ Immediately after logging to the spreadsheet, check whether ANY of these fields
 - Company Second Interview
 
 For EACH of the above fields that contains a date/time, create a Google Calendar event using the create_calendar_event tool:
-- Title format: "[<Recruiter NaME> Call] Company - Role" or "[First Interview] Company - Role" or "[Second Interview] Company - Role"
+- Title format: "[<Recruiter Name> Call] Company - Role" or "[First Interview] Company - Role" or "[Second Interview] Company - Role"
 - Start date/time: extracted from the email (convert to ISO 8601)
 - Duration: 30 minutes unless otherwise specified in the email
 - Location: the video meeting link, phone number, or platform name
@@ -34,12 +31,12 @@ STEP 3: COMPANY INTERVIEW TRACKING
 When an email indicates advancement beyond the recruiter screen to a company interview:
 - Populate the Company First Interview or Company Second Interview field with details
 - Those details should include company contact info (interviewer name, email, phone)
-- Then immeidately create a calendar event for the new interview date/time including interviewer name, email, phone
+- Then immediately create a calendar event for the new interview date/time including interviewer name, email, phone
 
 STRICT CONSTRAINTS:
-- Do not make up phone numbers, links, dates, or anything at all.  If it does not exist in text wihtin a verifiable email, IT DOES NOT EXIST.
-- PAST-DATE CHECK: Before creating a calendar event, compare the proposed meeting date/time against today's date. If the meeting date has already passed, do NOT create a calendar event for it. Still log it to the spreadsheet, but skip the calendar step. The tool will also enforce this server-side.
+- Do not make up phone numbers, links, dates, or anything at all. If it does not exist in text within a verifiable email, IT DOES NOT EXIST.
+- PAST-DATE CHECK: Before creating a calendar event: 1) verify today's date from an external, reliable source; 2) compare the proposed meeting date/time against today's date; 3) if the meeting date has already passed, do NOT create a calendar event for it. Still log it to the spreadsheet, but skip the calendar step. The tool will also enforce this server-side.
 - As described in more detail below, each new date/time value in a scheduling column = one new calendar event. Never skip this.
 - Always use the same account for calendar events as was used for email fetching.
-- Do not create duplicate calendar events for the same meeting.
-- If information is not present in the email, leave that field empty do ot guess.
+- Do not create duplicate calendar events for the same meeting (same company representative && same job description | same company && same date time)
+- If information is not present in the email, leave that field empty (it's OK!) - do not guess or make up information.

src/tools/tools-email.ts

@@ -3,303 +3,358 @@ import { gmail_v1 } from "googleapis";
 import fs from "fs";
 import { server } from "../McpServer.js";
 import {
-  accountSchema,
-  getGmailClient,
-  getSummaryPath,
-  loadClassificationPrompt,
-  loadActionPrompt,
+    accountSchema,
+    getGmailClient,
+    getSummaryPath,
+    loadClassificationPrompt,
+    loadActionPrompt,
 } from "../loaders/prompt-config-loaders.js";
 
 // ---------------------------------------------------------------------------
 // Email parsing helpers
 // ---------------------------------------------------------------------------
 export const getHeader = (
-  headers: gmail_v1.Schema$MessagePartHeader[] | undefined,
-  name: string
+    headers: gmail_v1.Schema$MessagePartHeader[] | undefined,
+    name: string
 ): string => {
-  if (!headers) return "";
-  const header = headers.find(
-    (h) => h.name?.toLowerCase() === name.toLowerCase()
-  );
-  return header?.value ?? "";
+    if (!headers) return "";
+    const header = headers.find(
+        (h) => h.name?.toLowerCase() === name.toLowerCase()
+    );
+    return header?.value ?? "";
 };
 
 export const decodeBody = (message: gmail_v1.Schema$Message): string => {
-  const parts = message.payload?.parts;
-  let encoded = "";
+    const parts = message.payload?.parts;
+    let encoded = "";
 
-  if (parts) {
-    const textPart = parts.find((p) => p.mimeType === "text/plain");
-    encoded = textPart?.body?.data ?? "";
+    if (parts) {
+        const textPart = parts.find((p) => p.mimeType === "text/plain");
+        encoded = textPart?.body?.data ?? "";
+
+        if (!encoded) {
+            const htmlPart = parts.find((p) => p.mimeType === "text/html");
+            encoded = htmlPart?.body?.data ?? "";
+        }
+    } else {
+        encoded = message.payload?.body?.data ?? "";
+    }
 
     if (!encoded) {
-      const htmlPart = parts.find((p) => p.mimeType === "text/html");
-      encoded = htmlPart?.body?.data ?? "";
+        return message.snippet ?? "";
     }
-  } else {
-    encoded = message.payload?.body?.data ?? "";
-  }
 
-  if (!encoded) {
-    return message.snippet ?? "";
-  }
-
-  return Buffer.from(encoded, "base64url").toString("utf-8");
+    return Buffer.from(encoded, "base64url").toString("utf-8");
 };
 
 // ---------------------------------------------------------------------------
 // Tool: fetch_new_emails
 // ---------------------------------------------------------------------------
 server.registerTool(
-  "fetch_new_emails",
-  {
-    description:
-      "Fetch unread emails from a Gmail inbox. Returns sender, date, " +
-      "subject, message ID, and body text for each message. The message IDs " +
-      "can be passed to delete_emails later. Specify which account to fetch from.",
-    inputSchema: {
-      account: accountSchema,
-      maxResults: z
-        .number()
-        .min(1)
-        .max(100)
-        .describe("Maximum number of unread emails to fetch (1-100)"),
+    "fetch_new_emails",
+    {
+        description:
+            "Fetch unread emails from a Gmail inbox. Returns sender, date, " +
+            "subject, message ID, and body text for each message. The message IDs " +
+            "must be passed to star_emails after evaluation. Specify which account to fetch from.",
+        inputSchema: {
+            account: accountSchema,
+            maxResults: z
+                .number()
+                .min(1)
+                .max(200)
+                .describe("Maximum number of unread emails to fetch (1-200)"),
+        },
     },
-  },
-  async ({ account, maxResults }) => {
-    try {
-      const gmail = getGmailClient(account);
+    async ({ account, maxResults }) => {
+        try {
+            const gmail = getGmailClient(account);
 
-      const listResponse = await gmail.users.messages.list({
-        userId: "me",
-        q: "is:unread",
-        maxResults,
-      });
+            const listResponse = await gmail.users.messages.list({
+                userId: "me",
+                q: "is:unread",
+                maxResults,
+            });
 
-      const messageIds = listResponse.data.messages ?? [];
+            const messageIds = listResponse.data.messages ?? [];
 
-      if (messageIds.length === 0) {
-        return {
-          content: [{ type: "text" as const, text: "No unread emails found." }],
-        };
-      }
+            if (messageIds.length === 0) {
+                return {
+                    content: [{ type: "text" as const, text: "No unread emails found." }],
+                };
+            }
 
-      const emails: string[] = [];
+            const emails: string[] = [];
 
-      for (const msg of messageIds) {
-        const detail = await gmail.users.messages.get({
-          userId: "me",
-          id: msg.id!,
-          format: "full",
-        });
+            for (const msg of messageIds) {
+                const detail = await gmail.users.messages.get({
+                    userId: "me",
+                    id: msg.id!,
+                    format: "full",
+                });
 
-        const headers = detail.data.payload?.headers;
-        const from = getHeader(headers, "From");
-        const subject = getHeader(headers, "Subject");
-        const date = getHeader(headers, "Date");
-        const body = decodeBody(detail.data);
+                const headers = detail.data.payload?.headers;
+                const from = getHeader(headers, "From");
+                const subject = getHeader(headers, "Subject");
+                const date = getHeader(headers, "Date");
+                const body = decodeBody(detail.data);
 
-        const truncatedBody =
-          body.length > 2000 ? body.substring(0, 2000) + "\n[...truncated]" : body;
+                const truncatedBody =
+                    body.length > 2000 ? body.substring(0, 2000) + "\n[...truncated]" : body;
 
-        emails.push(
-          [
-            `MESSAGE_ID: ${msg.id}`,
-            `FROM: ${from}`,
-            `DATE: ${date}`,
-            `SUBJECT: ${subject}`,
-            `BODY:\n${truncatedBody}`,
-          ].join("\n")
-        );
-      }
+                emails.push(
+                    [
+                        `MESSAGE_ID: ${msg.id}`,
+                        `FROM: ${from}`,
+                        `DATE: ${date}`,
+                        `SUBJECT: ${subject}`,
+                        `BODY:\n${truncatedBody}`,
+                    ].join("\n")
+                );
+            }
 
-      const classificationInstructions = loadClassificationPrompt();
-      const actionInstructions = loadActionPrompt();
-      const instructionsBlock =
-        (classificationInstructions
-          ? `\n\n${"=".repeat(60)}\nCLASSIFICATION INSTRUCTIONS (PHASE 1):\n${"=".repeat(60)}\n${classificationInstructions}`
-          : "") +
-        (actionInstructions
-          ? `\n\n${"=".repeat(60)}\nACTION INSTRUCTIONS (PHASE 2):\n${"=".repeat(60)}\n${actionInstructions}`
-          : "");
+            const classificationInstructions = loadClassificationPrompt();
+            const actionInstructions = loadActionPrompt();
+            const instructionsBlock =
+                (classificationInstructions
+                    ? `\n\n${"=".repeat(60)}\nCLASSIFICATION INSTRUCTIONS (PHASE 1):\n${"=".repeat(60)}\n${classificationInstructions}`
+                    : "") +
+                (actionInstructions
+                    ? `\n\n${"=".repeat(60)}\nACTION INSTRUCTIONS (PHASE 2):\n${"=".repeat(60)}\n${actionInstructions}`
+                    : "");
 
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text:
-              `Found ${emails.length} unread email(s):\n\n` +
-              `${"=".repeat(60)}\n${emails.join(`\n${"=".repeat(60)}\n`)}` +
-              instructionsBlock,
-          },
-        ],
-      };
-    } catch (error) {
-      const errMsg = error instanceof Error ? error.message : String(error);
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: `Error fetching emails: ${errMsg}`,
-          },
-        ],
-      };
+            return {
+                content: [
+                    {
+                        type: "text" as const,
+                        text:
+                            `Found ${emails.length} unread email(s):\n\n` +
+                            `${"=".repeat(60)}\n${emails.join(`\n${"=".repeat(60)}\n`)}` +
+                            instructionsBlock,
+                    },
+                ],
+            };
+        } catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text" as const,
+                        text: `Error fetching emails: ${errMsg}`,
+                    },
+                ],
+            };
+        }
     }
-  }
 );
 
 // ---------------------------------------------------------------------------
 // Tool: delete_emails
 // ---------------------------------------------------------------------------
 server.registerTool(
-  "delete_emails",
-  {
-    description:
-      "Move emails to trash by their Gmail message IDs. Use this for " +
-      "category A (acknowledgements) and category C (rejections) emails. " +
-      "Specify which account the emails belong to.",
-    inputSchema: {
-      account: accountSchema,
-      messageIds: z
-        .array(z.string())
-        .describe("Array of Gmail message IDs to move to trash"),
+    "delete_emails",
+    {
+        description:
+            "Move emails to trash by their Gmail message IDs. Use this for " +
+            "category A (acknowledgements) and category C (rejections) emails. " +
+            "Specify which account the emails belong to.",
+        inputSchema: {
+            account: accountSchema,
+            messageIds: z
+                .array(z.string())
+                .describe("Array of Gmail message IDs to move to trash"),
+        },
     },
-  },
-  async ({ account, messageIds }) => {
-    try {
-      const gmail = getGmailClient(account);
-      const results: string[] = [];
-
-      for (const id of messageIds) {
+    async ({ account, messageIds }) => {
         try {
-          await gmail.users.messages.trash({
-            userId: "me",
-            id,
-          });
-          results.push(`Trashed: ${id}`);
-        } catch (err) {
-          const errMsg = err instanceof Error ? err.message : String(err);
-          results.push(`Failed to trash ${id}: ${errMsg}`);
-        }
-      }
+            const gmail = getGmailClient(account);
+            const results: string[] = [];
 
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: `Delete results:\n${results.join("\n")}`,
-          },
-        ],
-      };
-    } catch (error) {
-      const errMsg = error instanceof Error ? error.message : String(error);
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: `Error deleting emails: ${errMsg}`,
-          },
-        ],
-      };
+            for (const id of messageIds) {
+                try {
+                    await gmail.users.messages.trash({
+                        userId: "me",
+                        id,
+                    });
+                    results.push(`Trashed: ${id}`);
+                } catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    results.push(`Failed to trash ${id}: ${errMsg}`);
+                }
+            }
+
+            return {
+                content: [
+                    {
+                        type: "text" as const,
+                        text: `Delete results:\n${results.join("\n")}`,
+                    },
+                ],
+            };
+        } catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text" as const,
+                        text: `Error deleting emails: ${errMsg}`,
+                    },
+                ],
+            };
+        }
     }
-  }
 );
 
 // ---------------------------------------------------------------------------
 // Tool: append_to_summary
 // ---------------------------------------------------------------------------
 interface SummaryEntry {
-  senderName: string;
-  senderEmail: string;
-  dateReceived: string;
-  subject: string;
-  category: "B" | "D";
-  addedAt: string;
+    senderName: string;
+    senderEmail: string;
+    dateReceived: string;
+    subject: string;
+    category: "B" | "D";
+    addedAt: string;
 }
 
 server.registerTool(
-  "append_to_summary",
-  {
-    description:
-      "Append classified email entries to the local summary file. Use this " +
-      "for category B (advancement to next step) and category D (other) emails. " +
-      "Each entry records the sender, date, subject, and category. " +
-      "Specify which account the emails belong to.",
-    inputSchema: {
-      account: accountSchema,
-      entries: z
-        .array(
-          z.object({
-            senderName: z.string().describe("Name of the sender"),
-            senderEmail: z.string().describe("Email address of the sender"),
-            dateReceived: z
-              .string()
-              .describe("Date and time the email was received"),
-            subject: z.string().describe("Email subject line"),
-            category: z
-              .enum(["B", "D"])
-              .describe(
-                "Category: B = advancement to next step, D = other/uncategorized"
-              ),
-          })
-        )
-        .describe("Array of email summary entries to append"),
+    "append_to_summary",
+    {
+        description:
+            "Append classified email entries to the local summary file. Use this " +
+            "for category B (advancement to next step) and category D (other) emails. " +
+            "Each entry records the sender, date, subject, and category. " +
+            "Specify which account the emails belong to.",
+        inputSchema: {
+            account: accountSchema,
+            entries: z
+                .array(
+                    z.object({
+                        senderName: z.string().describe("Name of the sender"),
+                        senderEmail: z.string().describe("Email address of the sender"),
+                        dateReceived: z
+                            .string()
+                            .describe("Date and time the email was received"),
+                        subject: z.string().describe("Email subject line"),
+                        category: z
+                            .enum(["B", "D"])
+                            .describe(
+                                "Category: B = advancement to next step, D = other/uncategorized"
+                            ),
+                    })
+                )
+                .describe("Array of email summary entries to append"),
+        },
     },
-  },
-  async ({ account, entries }) => {
-    try {
-      const summaryPath = getSummaryPath(account);
+    async ({ account, entries }) => {
+        try {
+            const summaryPath = getSummaryPath(account);
 
-      let summary: SummaryEntry[] = [];
-      if (fs.existsSync(summaryPath)) {
-        summary = JSON.parse(fs.readFileSync(summaryPath, "utf-8"));
-      }
+            let summary: SummaryEntry[] = [];
+            if (fs.existsSync(summaryPath)) {
+                summary = JSON.parse(fs.readFileSync(summaryPath, "utf-8"));
+            }
 
-      const now = new Date();
-      const nowIso = now.toISOString();
-      const newEntries: SummaryEntry[] = entries.map((e) => ({
-        ...e,
-        addedAt: nowIso,
-      }));
+            const now = new Date();
+            const nowIso = now.toISOString();
+            const newEntries: SummaryEntry[] = entries.map((e) => ({
+                ...e,
+                addedAt: nowIso,
+            }));
 
-      summary.push(...newEntries);
+            summary.push(...newEntries);
 
-      const RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
-      const cutoff = now.getTime() - RETENTION_MS;
-      const beforePurge = summary.length;
-      summary = summary.filter(
-        (entry) => new Date(entry.addedAt).getTime() >= cutoff
-      );
-      const purged = beforePurge - summary.length;
+            const RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+            const cutoff = now.getTime() - RETENTION_MS;
+            const beforePurge = summary.length;
+            summary = summary.filter(
+                (entry) => new Date(entry.addedAt).getTime() >= cutoff
+            );
+            const purged = beforePurge - summary.length;
 
-      fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2));
+            fs.writeFileSync(summaryPath, JSON.stringify(summary, null, 2));
 
-      const purgeNote = purged > 0
-        ? `\nPurged ${purged} entry/entries older than 30 days.`
-        : "";
+            const purgeNote = purged > 0
+                ? `\nPurged ${purged} entry/entries older than 30 days.`
+                : "";
 
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text:
-              `Appended ${newEntries.length} entry/entries to summary.\n` +
-              `Total entries in summary: ${summary.length}\n` +
-              `Summary file: ${summaryPath}` +
-              purgeNote,
-          },
-        ],
-      };
-    } catch (error) {
-      const errMsg = error instanceof Error ? error.message : String(error);
-      return {
-        content: [
-          {
-            type: "text" as const,
-            text: `Error appending to summary: ${errMsg}`,
-          },
-        ],
-      };
+            return {
+                content: [
+                    {
+                        type: "text" as const,
+                        text:
+                            `Appended ${newEntries.length} entry/entries to summary.\n` +
+                            `Total entries in summary: ${summary.length}\n` +
+                            `Summary file: ${summaryPath}` +
+                            purgeNote,
+                    },
+                ],
+            };
+        } catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text" as const,
+                        text: `Error appending to summary: ${errMsg}`,
+                    },
+                ],
+            };
+        }
+    }
+);
+// --------------------------------------------------------------------------- //
+// Tool: star_emails
+// --------------------------------------------------------------------------- //
+server.registerTool(
+    "star_emails",
+    {
+        description: "Mark reviewed emails with a star and mark them as read in Gmail. " +
+            "Use this for all reviewed messages (Categories A, B, C, and D) " +
+            "to signal they have been processed. Specify which account the emails belong to.",
+        inputSchema: {
+            account: accountSchema,
+            messageIds: z
+                .array(z.string())
+                .describe("Array of Gmail message IDs to star and mark read"),
+        },
+    },
+    async ({ account, messageIds }) => {
+        try {
+            if (messageIds.length === 0) {
+                return { content: [{ type: "text" as const, text: "No message IDs provided." }] };
+            }
+
+            const gmail = getGmailClient(account);
+
+            // Batch modify allows updating up to 1000 messages in a single API call
+            await gmail.users.messages.batchModify({
+                userId: "me",
+                requestBody: {
+                    ids: messageIds,
+                    addLabelIds: ["STARRED"],
+                    removeLabelIds: ["UNREAD"]
+                }
+            });
+
+            return {
+                content: [
+                    {
+                        type: "text" as const,
+                        text: `Successfully starred and marked read ${messageIds.length} email(s).`,
+                    },
+                ],
+            };
+        } catch (error) {
+            const errMsg = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text" as const,
+                        text: `Error starring emails: ${errMsg}`,
+                    },
+                ],
+            };
+        }
     }
-  }
 );